@canonical/pragma-cli 0.31.0 → 0.33.0

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

@@ -1,197 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { buildQuery } from "../../shared/buildQuery.js";
-import { P } from "../../shared/prefixes.js";
-import type { OntologySummary } from "../../shared/types/index.js";
-import findNamespace from "../helpers/findNamespace.js";
-
-const SH = "http://www.w3.org/ns/shacl#";
-
-/** Check whether a URI belongs to the anatomy namespace. */
-function isAnatomyTerm(uri: string): boolean {
-  return uri.toLowerCase().includes("anatomy");
-}
-
-/** Per-namespace URI accumulator. */
-function add(
-  map: Map<string, Set<string>>,
-  namespace: string,
-  uri: string,
-): void {
-  const set = map.get(namespace) ?? new Set();
-  set.add(uri);
-  map.set(namespace, set);
-}
-
-/**
- * Derive a namespace from a URI when no registered prefix matches: cut
- * after the last `#`, else after the last `/`. Keeps ontologies loaded
- * without a declared prefix (e.g. a package that has not yet published
- * its `pragma.prefixes`) visible in the listing instead of silently
- * dropping their whole TBox.
- */
-function deriveNamespace(uri: string): string | undefined {
-  const hash = uri.lastIndexOf("#");
-  if (hash > 0) return uri.slice(0, hash + 1);
-  // Scheme-agnostic: any slash after the `scheme://` authority separator
-  // marks a path segment; a URI with no path (http://host) has none.
-  const authority = uri.indexOf("://");
-  if (authority < 0) return undefined;
-  const slash = uri.lastIndexOf("/");
-  return slash > authority + 2 ? uri.slice(0, slash + 1) : undefined;
-}
-
-/**
- * List all loaded ontology namespaces with their header metadata (title,
- * version) and counts: classes, relations (object properties), attributes
- * (datatype properties), SHACL shapes, and anatomy terms.
- *
- * Discovers namespaces by querying for `owl:Class` and
- * `owl:ObjectProperty`/`owl:DatatypeProperty` definitions, then maps
- * namespace URIs back to prefixes via `store.prefixes`. Four whole-store
- * queries regardless of how many namespaces are loaded.
- *
- * @param store - The ke store to query.
- * @returns An array of {@link OntologySummary} sorted alphabetically by prefix.
- *
- * @note Queries ke store
- */
-export default async function listOntologies(
-  store: Store,
-): Promise<OntologySummary[]> {
-  const classResult = await store.query(
-    buildQuery(`
-      SELECT ?class
-      WHERE { ?class a ${P.owl}Class }
-    `),
-  );
-
-  const propResult = await store.query(
-    buildQuery(`
-      SELECT ?prop ?propType
-      WHERE {
-        ?prop a ?propType .
-        VALUES ?propType { ${P.owl}ObjectProperty ${P.owl}DatatypeProperty }
-      }
-    `),
-  );
-
-  const shapeResult = await store.query(
-    buildQuery(`
-      SELECT ?shape ?target
-      WHERE {
-        ?shape a <${SH}NodeShape> .
-        OPTIONAL { ?shape <${SH}targetClass> ?target }
-      }
-    `),
-  );
-
-  const metaResult = await store.query(
-    buildQuery(`
-      SELECT ?ont ?title ?version
-      WHERE {
-        ?ont a ${P.owl}Ontology .
-        OPTIONAL { ?ont ${P.rdfs}label ?title }
-        OPTIONAL { ?ont ${P.owl}versionInfo ?version }
-      }
-      ORDER BY ?ont
-    `),
-  );
-
-  const prefixEntries = Object.entries(store.prefixes);
-  // Everything below is keyed by namespace URI so ontologies without a
-  // registered prefix still surface in the listing.
-  const nsOf = (uri: string): string | undefined =>
-    findNamespace(uri, prefixEntries)?.namespace ?? deriveNamespace(uri);
-  const classCounts = new Map<string, Set<string>>();
-  const relationCounts = new Map<string, Set<string>>();
-  const attributeCounts = new Map<string, Set<string>>();
-  const shapeCounts = new Map<string, Set<string>>();
-  const anatomyCounts = new Map<string, Set<string>>();
-  const meta = new Map<string, { title?: string; version?: string }>();
-
-  if (classResult.type === "select") {
-    for (const b of classResult.bindings) {
-      const uri = b.class ?? "";
-      const ns = nsOf(uri);
-      if (ns) {
-        add(classCounts, ns, uri);
-        if (isAnatomyTerm(uri)) add(anatomyCounts, ns, uri);
-      }
-    }
-  }
-
-  if (propResult.type === "select") {
-    for (const b of propResult.bindings) {
-      const uri = b.prop ?? "";
-      const ns = nsOf(uri);
-      if (ns) {
-        const kind = b.propType?.includes("ObjectProperty")
-          ? relationCounts
-          : attributeCounts;
-        add(kind, ns, uri);
-        if (isAnatomyTerm(uri)) add(anatomyCounts, ns, uri);
-      }
-    }
-  }
-
-  if (shapeResult.type === "select") {
-    for (const b of shapeResult.bindings) {
-      // Same attribution as `ontology show`: a shape counts for the
-      // namespace of the shape itself or of its target class.
-      const ns = b.shape ? nsOf(b.shape) : undefined;
-      const targetNs = b.target ? nsOf(b.target) : undefined;
-      const owner = ns ?? targetNs;
-      if (owner && b.shape) add(shapeCounts, owner, b.shape);
-    }
-  }
-
-  if (metaResult.type === "select") {
-    for (const b of metaResult.bindings) {
-      const ns = b.ont ? nsOf(b.ont) : undefined;
-      if (ns && !meta.has(ns)) {
-        meta.set(ns, {
-          ...(b.title ? { title: b.title } : {}),
-          ...(b.version ? { version: b.version } : {}),
-        });
-      }
-    }
-  }
-
-  // A namespace that only contributes SHACL shapes still surfaces; one
-  // that only declares an owl:Ontology header (no terms at all) does not —
-  // an empty TBox is not a listable ontology.
-  const allNamespaces = new Set([
-    ...classCounts.keys(),
-    ...relationCounts.keys(),
-    ...attributeCounts.keys(),
-    ...anatomyCounts.keys(),
-    ...shapeCounts.keys(),
-  ]);
-
-  const summaries = [...allNamespaces].map((namespace) => {
-    const prefix = prefixEntries.find(([, ns]) => ns === namespace)?.[0] ?? "";
-    const header = meta.get(namespace);
-    return {
-      prefix,
-      namespace,
-      ...(header?.title ? { title: header.title } : {}),
-      ...(header?.version ? { version: header.version } : {}),
-      classCount: classCounts.get(namespace)?.size ?? 0,
-      relationCount: relationCounts.get(namespace)?.size ?? 0,
-      attributeCount: attributeCounts.get(namespace)?.size ?? 0,
-      shapeCount: shapeCounts.get(namespace)?.size ?? 0,
-      anatomyCount: anatomyCounts.get(namespace)?.size ?? 0,
-    };
-  });
-
-  // Prefixed namespaces first (alphabetical), unprefixed after by URI.
-  return summaries.sort((a, b) =>
-    a.prefix && b.prefix
-      ? a.prefix.localeCompare(b.prefix)
-      : a.prefix
-        ? -1
-        : b.prefix
-          ? 1
-          : a.namespace.localeCompare(b.namespace),
-  );
-}

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

@@ -1,184 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { PragmaError } from "#error";
-import { createTestStore, DS_ALL_TTL } from "#testing";
-import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
-import showOntology from "./showOntology.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("showOntology", () => {
-  it("returns classes with attached properties for a prefix", async () => {
-    const result = await showOntology(store, "ds");
-    expect(result.prefix).toBe("ds");
-    expect(result.namespace).toBe(DEFAULT_PREFIX_MAP.ds);
-    expect(result.classes.length).toBeGreaterThan(0);
-
-    const uiBlock = result.classes.find((c) => c.iri === "ds:UIBlock");
-    expect(uiBlock).toBeDefined();
-    expect(uiBlock?.properties.map((p) => p.label)).toContain("name");
-  });
-
-  it("preserves all subClassOf edges as compact IRIs", async () => {
-    const result = await showOntology(store, "ds");
-    const component = result.classes.find((c) => c.label === "Component");
-    expect(component).toBeDefined();
-    expect(component?.subClassOf).toContain("ds:UIBlock");
-  });
-
-  it("orders classes topologically (parents before children)", async () => {
-    const result = await showOntology(store, "ds");
-    const order = result.classes.map((c) => c.iri);
-    expect(order.indexOf("ds:UIBlock")).toBeLessThan(
-      order.indexOf("ds:Component"),
-    );
-  });
-
-  it("includes rdfs:comment when declared", async () => {
-    const result = await showOntology(store, "ds");
-    const component = result.classes.find((c) => c.iri === "ds:Component");
-    expect(component?.comment).toBe("A reusable UI building block.");
-  });
-
-  it("counts instances per class", async () => {
-    const result = await showOntology(store, "ds");
-    const component = result.classes.find((c) => c.iri === "ds:Component");
-    expect(component?.instances).toBeGreaterThan(0);
-  });
-
-  it("marks functional properties", async () => {
-    const result = await showOntology(store, "ds");
-    const uiBlock = result.classes.find((c) => c.iri === "ds:UIBlock");
-    const tier = uiBlock?.properties.find((p) => p.iri === "ds:tier");
-    expect(tier?.functional).toBe(true);
-  });
-
-  it("attaches property domain and range as compact IRIs", async () => {
-    const result = await showOntology(store, "ds");
-    const uiBlock = result.classes.find((c) => c.iri === "ds:UIBlock");
-    const nameProp = uiBlock?.properties.find((p) => p.iri === "ds:name");
-    expect(nameProp).toBeDefined();
-    expect(nameProp?.domain).toBe("ds:UIBlock");
-    expect(nameProp?.kind).toBe("datatype");
-    expect(nameProp?.range).toBe("xsd:string");
-  });
-
-  it("emits a prefixes map covering the compact IRIs used", async () => {
-    const result = await showOntology(store, "ds");
-    expect(result.prefixes.ds).toBe(DEFAULT_PREFIX_MAP.ds);
-    expect(result.prefixes.xsd).toBeDefined();
-  });
-
-  it("surfaces the owl:Ontology header", async () => {
-    const result = await showOntology(store, "ds");
-    expect(result.meta?.title).toBe("Design System Ontology");
-    expect(result.meta?.version).toBe("0.1.0-test");
-  });
-
-  it("summarizes SHACL node shapes", async () => {
-    const result = await showOntology(store, "ds");
-    const shape = result.constraints?.find(
-      (c) => c.shape === "ds:ComponentShape",
-    );
-    expect(shape).toBeDefined();
-    expect(shape?.targetClass).toBe("ds:Component");
-    expect(shape?.propertyCount).toBe(2);
-  });
-
-  it("resolves full namespace URI", async () => {
-    const result = await showOntology(store, DEFAULT_PREFIX_MAP.ds);
-    expect(result.prefix).toBe("ds");
-    expect(result.classes.length).toBeGreaterThan(0);
-  });
-
-  it("throws PragmaError.invalidInput for unknown prefix", async () => {
-    await expect(showOntology(store, "unknown")).rejects.toThrow(PragmaError);
-
-    try {
-      await showOntology(store, "unknown");
-    } catch (e) {
-      expect((e as PragmaError).code).toBe("INVALID_INPUT");
-    }
-  });
-
-  it("returns cs ontology with standard classes", async () => {
-    const result = await showOntology(store, "cs");
-    expect(result.prefix).toBe("cs");
-    const standard = result.classes.find((c) => c.iri.includes("CodeStandard"));
-    expect(standard).toBeDefined();
-  });
-});
-
-describe("showOntology — class focus", () => {
-  it("deep-dives into a class by label", async () => {
-    const result = await showOntology(store, "ds", { class: "Component" });
-    const focus = result.focus;
-    expect(focus).toBeDefined();
-    expect(focus?.iri).toBe("ds:Component");
-    expect(focus?.superChain).toEqual(["ds:UIBlock"]);
-    expect(focus?.instances).toBeGreaterThan(0);
-  });
-
-  it("separates direct and inherited properties", async () => {
-    const result = await showOntology(store, "ds", { class: "Component" });
-    const inherited = result.focus?.inheritedProperties.map((p) => p.iri);
-    expect(inherited).toContain("ds:name");
-  });
-
-  it("finds reverse references (properties ranging over the class)", async () => {
-    const result = await showOntology(store, "ds", { class: "UIBlock" });
-    const refs = result.focus?.referencedBy.map((p) => p.iri);
-    expect(refs).toContain("ds:implementsBlock");
-  });
-
-  it("returns sample instance IRIs", async () => {
-    const result = await showOntology(store, "ds", { class: "Component" });
-    expect(result.focus?.sampleInstances.length).toBeGreaterThan(0);
-  });
-
-  it("emits runnable follow-up queries with compact IRIs", async () => {
-    const result = await showOntology(store, "ds", { class: "Component" });
-    const queries = result.focus?.queries ?? [];
-    expect(queries.length).toBeGreaterThan(0);
-    expect(queries[0]?.sparql).toBe(
-      "SELECT ?instance WHERE { ?instance a ds:Component } LIMIT 20",
-    );
-    // A sample-instance inspection query is included when instances exist.
-    expect(queries.some((q) => q.sparql.includes("?predicate ?object"))).toBe(
-      true,
-    );
-  });
-
-  it("accepts a compact IRI and a local name", async () => {
-    const byIri = await showOntology(store, "ds", { class: "ds:Component" });
-    expect(byIri.focus?.iri).toBe("ds:Component");
-
-    const byLocal = await showOntology(store, "ds", { class: "component" });
-    expect(byLocal.focus?.iri).toBe("ds:Component");
-  });
-
-  it("throws not-found with suggestions for an unknown class", async () => {
-    try {
-      await showOntology(store, "ds", { class: "Comp" });
-      expect.unreachable("should have thrown");
-    } catch (e) {
-      expect((e as PragmaError).code).toBe("ENTITY_NOT_FOUND");
-      expect((e as PragmaError).suggestions).toContain("Component");
-    }
-  });
-
-  it("still returns the full namespace structure alongside the focus", async () => {
-    const result = await showOntology(store, "ds", { class: "Component" });
-    expect(result.classes.length).toBeGreaterThan(0);
-    expect(result.focus).toBeDefined();
-  });
-});

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

@@ -1,323 +0,0 @@
-import type { Store } from "@canonical/ke";
-import { PragmaError } from "#error";
-import compactUri from "../../shared/compactUri.js";
-import { PREFIX_MAP } from "../../shared/prefixes.js";
-import type {
-  OntologyClass,
-  OntologyClassFocus,
-  OntologyConstraint,
-  OntologyDetailed,
-  OntologyMeta,
-  OntologyProperty,
-  OntologyQueryHint,
-} from "../../shared/types/index.js";
-import buildClassTree, { flattenClassTree } from "../helpers/buildClassTree.js";
-import queryClasses from "../helpers/queryClasses.js";
-import type { RawOntologyProperty } from "../helpers/queryProperties.js";
-import queryProperties from "../helpers/queryProperties.js";
-import {
-  queryConstraints,
-  queryInstanceCounts,
-  queryOntologyMeta,
-  querySampleInstances,
-} from "../helpers/queryTboxFacts.js";
-import resolvePrefix from "../helpers/resolvePrefix.js";
-
-/** Options for {@link showOntology}. */
-export interface ShowOntologyOptions {
-  /** Class to deep-dive into (label, local name, or compact IRI). */
-  readonly class?: string;
-}
-
-/**
- * Returns the complete TBox structure for a namespace: the class hierarchy
- * (topologically ordered, direct properties attached, instance counts),
- * unattached properties, SHACL constraint summaries, the owl:Ontology
- * header, and — when `options.class` is given — a per-class deep dive.
- *
- * This is the **single** structure every output mode projects; plain,
- * `--llm`, `--format json`, and the MCP envelope must render from it and
- * nothing else. All IRIs are compacted against the store's prefix map,
- * which is included in the result for lossless expansion.
- *
- * Accepts a short prefix (e.g. `ds`) or a full namespace URI.
- *
- * @note Queries ke store
- *
- * @param store - The ke store to query.
- * @param prefixOrUri - A short prefix or full namespace URI.
- * @param options - Optional class focus.
- * @returns An {@link OntologyDetailed} with classes and properties.
- * @throws PragmaError.invalidInput if the prefix or namespace is unknown.
- * @throws PragmaError.notFound if the namespace has no classes or
- *   properties, or the focused class does not exist.
- */
-export default async function showOntology(
-  store: Store,
-  prefixOrUri: string,
-  options: ShowOntologyOptions = {},
-): Promise<OntologyDetailed> {
-  const { prefix, namespace } = resolvePrefix(prefixOrUri, store.prefixes);
-
-  const [rawClasses, rawProperties, instanceCounts, rawConstraints, rawMeta] =
-    await Promise.all([
-      queryClasses(store, namespace),
-      queryProperties(store, namespace),
-      queryInstanceCounts(store, namespace),
-      queryConstraints(store, namespace),
-      queryOntologyMeta(store, namespace),
-    ]);
-
-  if (rawClasses.length === 0 && rawProperties.length === 0) {
-    throw PragmaError.notFound("ontology", prefixOrUri, {
-      recovery: {
-        message: "List loaded ontologies.",
-        cli: "pragma ontology list",
-        mcp: { tool: "ontology_list" },
-      },
-    });
-  }
-
-  // Core RDF vocabularies (xsd etc.) plus the store's resolved package
-  // prefixes; the store map wins on collisions.
-  const compactionMap: Readonly<Record<string, string>> = {
-    ...PREFIX_MAP,
-    ...store.prefixes,
-  };
-  const usedPrefixes = new Set<string>([prefix]);
-  const compact = (uri: string): string => {
-    const compacted = compactUri(uri, compactionMap);
-    const colon = compacted.indexOf(":");
-    if (compacted !== uri && colon > 0) {
-      usedPrefixes.add(compacted.slice(0, colon));
-    }
-    return compacted;
-  };
-
-  const toProperty = (raw: RawOntologyProperty): OntologyProperty => ({
-    iri: compact(raw.uri),
-    label: raw.label,
-    kind: raw.kind,
-    ...(raw.domain ? { domain: compact(raw.domain) } : {}),
-    ...(raw.range ? { range: compact(raw.range) } : {}),
-    ...(raw.functional ? { functional: true as const } : {}),
-  });
-
-  // Attach properties to their domain class; the rest are unattached.
-  const classUris = new Set(rawClasses.map((c) => c.uri));
-  const byDomain = new Map<string, OntologyProperty[]>();
-  const unattached: OntologyProperty[] = [];
-  for (const raw of rawProperties) {
-    if (raw.domain !== undefined && classUris.has(raw.domain)) {
-      const attached = byDomain.get(raw.domain) ?? [];
-      attached.push(toProperty(raw));
-      byDomain.set(raw.domain, attached);
-    } else {
-      unattached.push(toProperty(raw));
-    }
-  }
-
-  const unordered: OntologyClass[] = rawClasses.map((raw) => {
-    const instances = instanceCounts.get(raw.uri) ?? 0;
-    return {
-      iri: compact(raw.uri),
-      label: raw.label,
-      ...(raw.comment ? { comment: raw.comment } : {}),
-      subClassOf: raw.subClassOf.map(compact),
-      ...(instances > 0 ? { instances } : {}),
-      properties: (byDomain.get(raw.uri) ?? []).sort((a, b) =>
-        a.label.localeCompare(b.label),
-      ),
-    };
-  });
-
-  // Canonical ordering: pre-order walk of the tree every renderer shares.
-  const classes = flattenClassTree(buildClassTree(unordered));
-
-  const constraints: OntologyConstraint[] = rawConstraints.map((raw) => ({
-    shape: compact(raw.shape),
-    ...(raw.targetClass ? { targetClass: compact(raw.targetClass) } : {}),
-    propertyCount: raw.propertyCount,
-  }));
-
-  const meta: OntologyMeta | undefined = rawMeta
-    ? {
-        ...(rawMeta.title ? { title: rawMeta.title } : {}),
-        ...(rawMeta.version ? { version: rawMeta.version } : {}),
-        ...(rawMeta.imports.length > 0
-          ? { imports: rawMeta.imports.map(compact) }
-          : {}),
-      }
-    : undefined;
-
-  const focus = options.class
-    ? await buildFocus(store, options.class, {
-        prefix,
-        namespace,
-        classes,
-        unattached,
-        constraints,
-        instanceCounts,
-        rawClassUris: rawClasses.map((c) => c.uri),
-        compactionMap,
-      })
-    : undefined;
-
-  const prefixes = Object.fromEntries(
-    [...usedPrefixes]
-      .sort()
-      .map((p) => [p, compactionMap[p]])
-      .filter(([, ns]) => ns !== undefined),
-  );
-
-  return {
-    prefix,
-    namespace,
-    prefixes,
-    ...(meta ? { meta } : {}),
-    classes,
-    unattached: unattached.sort((a, b) => a.label.localeCompare(b.label)),
-    ...(constraints.length > 0 ? { constraints } : {}),
-    ...(focus ? { focus } : {}),
-  };
-}
-
-interface FocusContext {
-  readonly prefix: string;
-  readonly namespace: string;
-  readonly classes: readonly OntologyClass[];
-  readonly unattached: readonly OntologyProperty[];
-  readonly constraints: readonly OntologyConstraint[];
-  readonly instanceCounts: ReadonlyMap<string, number>;
-  readonly rawClassUris: readonly string[];
-  readonly compactionMap: Readonly<Record<string, string>>;
-}
-
-/**
- * Assemble the per-class deep dive from the already-loaded structure plus
- * one sample-instances query. Everything else (chain, subclasses, reverse
- * references, inherited properties) derives from the namespace data.
- */
-async function buildFocus(
-  store: Store,
-  classQuery: string,
-  ctx: FocusContext,
-): Promise<OntologyClassFocus> {
-  const needle = classQuery.toLowerCase();
-  const target = ctx.classes.find(
-    (c) =>
-      c.iri.toLowerCase() === needle ||
-      c.label.toLowerCase() === needle ||
-      localName(c.iri).toLowerCase() === needle,
-  );
-
-  if (!target) {
-    throw PragmaError.notFound("class", classQuery, {
-      suggestions: ctx.classes
-        .map((c) => localName(c.iri))
-        .filter((name) => name.toLowerCase().includes(needle))
-        .slice(0, 5),
-      recovery: {
-        message: "Show the namespace's class hierarchy.",
-        cli: `pragma ontology show ${ctx.prefix}`,
-        mcp: { tool: "ontology_show", params: { prefix: ctx.prefix } },
-      },
-    });
-  }
-
-  const byIri = new Map(ctx.classes.map((c) => [c.iri, c]));
-
-  // Superclass chain within the namespace, nearest first, cycle-safe.
-  const superChain: string[] = [];
-  let cursor = target.subClassOf.find((p) => byIri.has(p));
-  while (cursor !== undefined && !superChain.includes(cursor)) {
-    superChain.push(cursor);
-    cursor = byIri.get(cursor)?.subClassOf.find((p) => byIri.has(p));
-  }
-
-  const inheritedProperties = superChain.flatMap(
-    (iri) => byIri.get(iri)?.properties ?? [],
-  );
-
-  const allProperties = [
-    ...ctx.classes.flatMap((c) => c.properties),
-    ...ctx.unattached,
-  ];
-
-  // The focused class's full URI is recoverable from the raw list (same
-  // index space as ctx.classes before ordering is irrelevant — match by
-  // compacted form).
-  const fullUri =
-    ctx.rawClassUris.find(
-      (uri) => compactUri(uri, ctx.compactionMap) === target.iri,
-    ) ?? target.iri;
-
-  const sampleInstances = (await querySampleInstances(store, fullUri)).map(
-    (uri) => compactUri(uri, ctx.compactionMap),
-  );
-
-  const referencedBy = allProperties
-    .filter((p) => p.range === target.iri && p.domain !== target.iri)
-    .sort((a, b) => a.label.localeCompare(b.label));
-
-  return {
-    iri: target.iri,
-    label: target.label,
-    ...(target.comment ? { comment: target.comment } : {}),
-    superChain,
-    subclasses: ctx.classes
-      .filter((c) => c.subClassOf.includes(target.iri))
-      .map((c) => c.iri)
-      .sort(),
-    instances: ctx.instanceCounts.get(fullUri) ?? 0,
-    directProperties: target.properties,
-    inheritedProperties,
-    referencedBy,
-    sampleInstances,
-    queries: buildQueryHints(target, referencedBy, sampleInstances),
-  };
-}
-
-/**
- * Ready-to-run SPARQL for the natural follow-ups from a class deep dive.
- * Compact IRIs are used throughout — `pragma graph query` resolves them
- * against the store's prefix map, so each hint is directly pasteable.
- */
-function buildQueryHints(
-  target: OntologyClass,
-  referencedBy: readonly OntologyProperty[],
-  sampleInstances: readonly string[],
-): OntologyQueryHint[] {
-  const hints: OntologyQueryHint[] = [
-    {
-      label: `instances of ${target.iri}`,
-      sparql: `SELECT ?instance WHERE { ?instance a ${target.iri} } LIMIT 20`,
-    },
-  ];
-
-  const relation =
-    target.properties.find((p) => p.kind === "object") ??
-    referencedBy.find((p) => p.kind === "object");
-  if (relation) {
-    hints.push({
-      label: `traverse ${relation.iri}`,
-      sparql: `SELECT ?from ?to WHERE { ?from ${relation.iri} ?to } LIMIT 10`,
-    });
-  }
-
-  const sample = sampleInstances[0];
-  if (sample !== undefined) {
-    hints.push({
-      label: `everything about ${sample}`,
-      sparql: `SELECT ?predicate ?object WHERE { ${sample} ?predicate ?object }`,
-    });
-  }
-
-  return hints;
-}
-
-function localName(iri: string): string {
-  const colon = iri.lastIndexOf(":");
-  const slash = iri.lastIndexOf("/");
-  return iri.slice(Math.max(colon, slash) + 1);
-}