@canonical/pragma-cli 0.30.0 → 0.31.0

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

@@ -2,7 +2,7 @@ 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 { PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
 import showOntology from "./showOntology.js";
 
 let store: Store;
@@ -17,31 +17,85 @@ beforeAll(async () => {
 afterAll(() => cleanup());
 
 describe("showOntology", () => {
-  it("returns classes and properties for a prefix", async () => {
+  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(PREFIX_MAP.ds);
+    expect(result.namespace).toBe(DEFAULT_PREFIX_MAP.ds);
     expect(result.classes.length).toBeGreaterThan(0);
-    expect(result.properties.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("includes class labels and superclass relationships", async () => {
+  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?.superclass).toContain("UIBlock");
+    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("includes property domain and range", async () => {
+  it("attaches property domain and range as compact IRIs", async () => {
     const result = await showOntology(store, "ds");
-    const nameProp = result.properties.find((p) => p.uri.endsWith("name"));
+    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).toContain("UIBlock");
-    expect(nameProp?.type).toBe("datatype");
+    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, PREFIX_MAP.ds);
+    const result = await showOntology(store, DEFAULT_PREFIX_MAP.ds);
     expect(result.prefix).toBe("ds");
     expect(result.classes.length).toBeGreaterThan(0);
   });
@@ -59,7 +113,72 @@ describe("showOntology", () => {
   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.uri.includes("CodeStandard"));
+    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,12 +1,44 @@
 import type { Store } from "@canonical/ke";
 import { PragmaError } from "#error";
-import type { OntologyDetailed } from "../../shared/types/index.js";
+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 detailed schema for a namespace, including its classes and properties.
+ * 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.
  *
@@ -14,20 +46,29 @@ import resolvePrefix from "../helpers/resolvePrefix.js";
  *
  * @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.
+ * @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 classes = await queryClasses(store, namespace);
-  const properties = await queryProperties(store, namespace);
+  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 (classes.length === 0 && properties.length === 0) {
+  if (rawClasses.length === 0 && rawProperties.length === 0) {
     throw PragmaError.notFound("ontology", prefixOrUri, {
       recovery: {
         message: "List loaded ontologies.",
@@ -37,5 +78,246 @@ export default async function showOntology(
     });
   }
 
-  return { prefix, namespace, classes, properties };
+  // 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);
 }

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

@@ -2,7 +2,7 @@ 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 { PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
 import showOntologyRaw from "./showOntologyRaw.js";
 
 let store: Store;
@@ -21,7 +21,9 @@ describe("showOntologyRaw", () => {
     const triples = await showOntologyRaw(store, "ds");
     expect(triples.length).toBeGreaterThan(0);
 
-    const hasDs = triples.some((t) => t.subject.startsWith(PREFIX_MAP.ds));
+    const hasDs = triples.some((t) =>
+      t.subject.startsWith(DEFAULT_PREFIX_MAP.ds),
+    );
     expect(hasDs).toBe(true);
   });
 

package/src/domains/ontology/stories.ts

@@ -19,15 +19,20 @@ import type {
   OntologyDetailed,
   OntologySummary,
 } from "../shared/types/index.js";
+import type { OntologyShowInput } from "./formatters/index.js";
 import { listFormatters, showFormatters } from "./formatters/index.js";
+import completeClassNames from "./helpers/completeClassNames.js";
+import expandOntologyIris from "./helpers/expandOntologyIris.js";
 import { listOntologies, showOntology } from "./operations/index.js";
 
 const ontologyListColumns: readonly ColumnDef<OntologySummary>[] = [
   { key: "prefix", label: "Prefix" },
   { key: "namespace", label: "Namespace" },
+  { key: "version", label: "Version" },
   { key: "classCount", label: "Classes" },
-  { key: "propertyCount", label: "Properties" },
-  { key: "anatomyCount", label: "Anatomies" },
+  { key: "relationCount", label: "Relations" },
+  { key: "attributeCount", label: "Attributes" },
+  { key: "shapeCount", label: "Shapes" },
 ];
 
 /** The `ontology list` / `ontology_list` read story. */
@@ -67,13 +72,13 @@ export const ontologyListStory: ReadStory<
 };
 
 /** The `ontology show <prefix>` / `ontology_show` read story. */
-export const ontologyShowStory: ReadStory<OntologyDetailed, OntologyDetailed> =
+export const ontologyShowStory: ReadStory<OntologyDetailed, OntologyShowInput> =
   {
     noun: "ontology",
     verb: "show",
     description: "Show ontology schema details",
     toolDescription:
-      "Show detailed schema for an ontology including classes and properties.",
+      "Show the TBox for a namespace: class hierarchy with instance counts and relations, plus metadata and constraints.",
     params: [
       {
         name: "prefix",
@@ -86,13 +91,53 @@ export const ontologyShowStory: ReadStory<OntologyDetailed, OntologyDetailed> =
           const all = await listOntologies(ctx.store);
           return all
             .map((o) => o.prefix)
-            .filter((p) => p.toLowerCase().startsWith(partial.toLowerCase()));
+            .filter(
+              (p) =>
+                p.length > 0 &&
+                p.toLowerCase().startsWith(partial.toLowerCase()),
+            );
         },
       },
+      {
+        name: "class",
+        type: "string",
+        description:
+          "Deep-dive into one class (label, local name, or compact IRI)",
+        toolDescription:
+          "Class to deep-dive into: super chain, direct + inherited properties, reverse references, sample instances, and follow-up queries",
+        complete: async (partial, cmdCtx) => {
+          const ctx = requirePragmaContext(cmdCtx);
+          return completeClassNames(ctx.store, partial);
+        },
+      },
+      {
+        name: "properties",
+        type: "boolean",
+        description:
+          "Include datatype properties (attributes); default shows relations only",
+      },
+      {
+        name: "fullUris",
+        type: "boolean",
+        description: "Show full URIs instead of compact prefixed IRIs",
+      },
+    ],
+    examples: [
+      "pragma ontology show ds",
+      "pragma ontology show ds --properties",
+      "pragma ontology show ds --full-uris --format json",
+      "pragma ontology show ds --class Component",
     ],
-    examples: ["pragma ontology show ds", "pragma ontology show cs --llm"],
-    resolve: (rt, params) => showOntology(rt.store, params.prefix as string),
-    toOutput: (ontology) => ontology,
+    resolve: (rt, params) =>
+      showOntology(rt.store, params.prefix as string, {
+        class: params.class as string | undefined,
+      }),
+    // --full-uris is applied here, once, so every projection (plain, llm,
+    // json, MCP condensed) inherits the same encoding from the same place.
+    toOutput: (ontology, params) => ({
+      ontology: params.fullUris ? expandOntologyIris(ontology) : ontology,
+      showProperties: Boolean(params.properties),
+    }),
     formatters: showFormatters,
     toEnvelope: (ontology) => ({ data: ontology }),
     guardParams: (params) =>

package/src/domains/refs/operations/updateRefs.ts

@@ -11,7 +11,6 @@ import { readConfig } from "#config";
 import { mergeAndParseRefs } from "../../shared/mergeAndParseRefs.js";
 import { cloneRef, fetchRef, pruneCache } from "./gitOps.js";
 import type { PackageRef, RawPackageEntry } from "./parseRef.js";
-import { parsePackageEntry } from "./parseRef.js";
 import { cacheRoot, gitCacheDir } from "./paths.js";
 
 // ---------------------------------------------------------------------------

package/src/domains/setup/commands/index.ts

@@ -3,4 +3,5 @@ export { default as allCommand } from "./all.js";
 export { default as completionsCommand } from "./completions.js";
 export { default as lspCommand } from "./lsp.js";
 export { default as mcpCommand } from "./mcp.js";
+export { default as setupCommand } from "./setup.js";
 export { default as skillsCommand } from "./skills.js";