@canonical/pragma-cli 0.33.0 → 0.35.0

package/src/capabilities/index.ts

@@ -1,46 +1,44 @@
 /**
- * The capability registry: the literal array of every capability module the
- * projectors consume (D8 — test-only fixtures are never listed here).
+ * The capability registry: every capability module the projectors consume
+ * (D8 — test-only fixtures are never listed here).
  *
- * The order is the authoring order; projectors sort where they need to. PR1
- * ships `info` + `config show` as real verbs and the hidden `meta` verbs
- * (`__complete`, `mcp`). Importing this barrel pulls only spec + formatter
- * modules — every run body is behind a lazy dynamic import — so the
+ * Two sources, in this order: the literal array of AUTHORED modules (in
+ * authoring order; projectors sort where they need to), then every story
+ * `pragma.conf.ts` declares that no authored module already claims. Since
+ * L-OPEN-9 no DATA noun is authored — the authored array is the kernel's own
+ * nouns and nothing else, and every design-system noun appears only in the
+ * config. No noun literal is written here: the second half is derived.
+ *
+ * Importing this barrel pulls only spec + formatter modules — every run body is
+ * behind a lazy dynamic import, and `distribution.ts` is zod-free — so the
  * `--help`/`__complete` fast paths stay free of the config reader and zod.
  */
 
-import type { CapabilityModule } from "../kernel/spec/types.js";
-import { blockModule } from "./block/index.js";
+import type { CapabilityModule } from "../kernel/spec/index.js";
 import { capabilitiesModule } from "./capabilities/index.js";
 import { colophonModule } from "./colophon/index.js";
 import { configModule } from "./config/index.js";
 import { createModule } from "./create/index.js";
+import { storyModules } from "./distribution.js";
 import { doctorModule } from "./doctor/index.js";
 import { graphModule } from "./graph/index.js";
 import { infoModule } from "./info/index.js";
 import { metaModule } from "./meta/index.js";
-import { modifierModule } from "./modifier/index.js";
 import { ontologyModule } from "./ontology/index.js";
 import { promptModule } from "./prompt/index.js";
 import { setupModule } from "./setup/index.js";
 import { skillModule } from "./skill/index.js";
 import { sourcesModule } from "./sources/index.js";
-import { standardModule } from "./standard/index.js";
-import { tierModule } from "./tier/index.js";
-import { tokenModule } from "./token/index.js";
 import { upgradeModule } from "./upgrade/index.js";
+import { versionModule } from "./version/index.js";
 
-/** Every capability module, in authoring order. */
-export const capabilities: readonly CapabilityModule[] = [
+/** The modules with hand-written code, in authoring order. */
+const authored: readonly CapabilityModule[] = [
   infoModule,
+  versionModule,
   configModule,
   createModule,
   sourcesModule,
-  standardModule,
-  tierModule,
-  modifierModule,
-  tokenModule,
-  blockModule,
   ontologyModule,
   skillModule,
   graphModule,
@@ -52,3 +50,11 @@ export const capabilities: readonly CapabilityModule[] = [
   colophonModule,
   metaModule,
 ];
+
+const claimed = new Set(authored.map((module) => module.name));
+
+/** Every capability module: the authored ones, then the unclaimed declared stories. */
+export const capabilities: readonly CapabilityModule[] = [
+  ...authored,
+  ...[...storyModules.values()].filter((module) => !claimed.has(module.name)),
+];

package/src/capabilities/info/collectInfo.ts

@@ -6,23 +6,27 @@
  * the npm registry — this deliberately REVERSES PR1's networkless-D11 stance for
  * `info` (the reversal IS the enrichment), unconditional because the covenant
  * `info` verb carries no flag, 3s timeout, silent-fail — and (b) a storeless
- * entity total from the pack index (`readPackIndex`, the same reader `sources
- * status` uses). Neither enrichment boots the store, so the storeless-guarantee
- * spy still sees `store.booted === false`. Kept out of the spec module so
- * building the command tree never pulls it onto the `--help` fast path.
+ * entity total, read from the index of whichever pack the boot decision names
+ * (`resolveSources` → `readPackIndex`, the same predicate `sources status` and
+ * `doctor` switch on) so `info` never counts a graph this project's reads
+ * refuse. Neither enrichment boots the store, so the storeless-guarantee spy
+ * still sees `store.booted === false`. Kept out of the spec module so building
+ * the command tree never pulls it onto the `--help` fast path.
  */
 
 import {
   entityTotal,
   readPackIndex,
 } from "../../kernel/completion/entitySource.js";
-import { readConfig } from "../../kernel/config/readConfig.js";
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
+import { readConfig } from "../../kernel/config/index.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
+import { resolveSources } from "../../kernel/runtime/resolveSources.js";
 import {
+  checkRegistryVersion,
   detectInstallSource,
+  PRAGMA_PACKAGE,
   pmUpdateCommand,
-} from "../shared/packageManager.js";
-import { checkRegistryVersion, PRAGMA_PACKAGE } from "../shared/registry.js";
+} from "../shared/index.js";
 import type { InfoData, InfoUpdate } from "./types.js";
 
 /**
@@ -50,8 +54,9 @@ export async function collectInfo(runtime: PragmaRuntime): Promise<InfoData> {
       : undefined;
   const updateSkipped = registry === undefined;
 
-  // Entity total: storeless — the same pack-index reader `sources status` uses.
-  const index = readPackIndex(runtime.cwd);
+  // Entity total: storeless, over the pack the boot decision names — so a
+  // configured-but-unbuilt project reports no total rather than the snapshot's.
+  const index = readPackIndex(resolveSources(layers, runtime.cwd));
   const entities = index ? entityTotal(index) : undefined;
 
   return {

package/src/capabilities/info/info.render.ts

@@ -2,8 +2,9 @@
  * Formatters for `pragma info` — plain, llm, json (no ink).
  */
 
+import { BIN_NAME } from "../../constants.js";
 import type { ConfigOrigin } from "../../kernel/config/types.js";
-import type { Formatters } from "../../kernel/spec/types.js";
+import type { Formatters } from "../../kernel/spec/index.js";
 import type { InfoData } from "./types.js";
 
 /** A `[layer]` marker for values a config file supplied (blank for defaults). */
@@ -15,7 +16,7 @@ export const infoFormatters: Formatters<InfoData> = {
   plain(data) {
     const { config } = data;
     const lines = [
-      `pragma v${data.version}`,
+      `${BIN_NAME} v${data.version}`,
       `  Installed via: ${data.installSource}`,
       `  tier: ${config.tier ?? "(none)"}${originMarker(config.origins.tier)}`,
       `  channel: ${config.channel}${originMarker(config.origins.channel)}`,
@@ -45,7 +46,7 @@ export const infoFormatters: Formatters<InfoData> = {
   llm(data) {
     const { config } = data;
     const lines = [
-      `# pragma v${data.version}`,
+      `# ${BIN_NAME} v${data.version}`,
       `- Installed via: ${data.installSource}`,
       `- Tier: ${config.tier ?? "(none)"}${originMarker(config.origins.tier)}`,
       `- Channel: ${config.channel}${originMarker(config.origins.channel)}`,

package/src/capabilities/info/info.verb.ts

@@ -6,8 +6,9 @@
  * the config reader or zod onto the fast path.
  */
 
+import { BIN_NAME } from "../../constants.js";
 import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { CapabilityModule, VerbSpec } from "../../kernel/spec/types.js";
+import type { CapabilityModule, VerbSpec } from "../../kernel/spec/index.js";
 import { infoFormatters } from "./info.render.js";
 import type { InfoData } from "./types.js";
 
@@ -18,9 +19,9 @@ const infoVerb: VerbSpec<Record<string, unknown>, InfoData> = {
   params: [],
   output: { formatters: infoFormatters },
   examples: [
-    { cmd: "pragma info", note: "human-readable summary" },
+    { cmd: `${BIN_NAME} info`, note: "human-readable summary" },
     {
-      cmd: "pragma info --format json",
+      cmd: `${BIN_NAME} info --format json`,
       note: "the full {ok,data,meta} envelope",
     },
   ],

package/src/capabilities/lazy.test.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { dirname, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { describe, expect, it } from "vitest";
 
@@ -45,10 +45,63 @@ describe("lazy dispatch — module-graph probe (PROTECTED)", () => {
     expect(has(graph, "info/info.render.ts")).toBe(true);
     expect(has(graph, "config/show.render.ts")).toBe(true);
 
-    // ...but run bodies and the config reader are only dynamic-imported.
+    // ...but run bodies and the config LAYER stay behind the dynamic boundary:
+    // no reader, no defaults layer, no zod schema. The distribution config
+    // itself IS on the graph — `constants.ts` projects the program's identity
+    // from it, `render/prefixes.ts` its domain namespaces and
+    // `kernel/vocabulary.ts` its domain terms — which is safe only because it
+    // is inert data (pinned below).
     expect(has(graph, "info/collectInfo.ts")).toBe(false);
     expect(has(graph, "config/collectConfigShow.ts")).toBe(false);
     expect(has(graph, "kernel/config/readConfig.ts")).toBe(false);
+    expect(has(graph, "kernel/config/defaults.ts")).toBe(false);
+    expect(has(graph, "kernel/config/schema.ts")).toBe(false);
+    expect(has(graph, "pragma.conf.ts")).toBe(true);
+  });
+
+  it("the distribution config is inert data — it imports nothing that runs", () => {
+    const conf = resolve(here, "../../pragma.conf.ts");
+    const pkgRoot = resolve(here, "../..");
+    // The graph walker follows `from "…"` textually and cannot tell an
+    // `import type` from a value import, so the type-only `config/types.ts`
+    // and `packs/types.ts` show up here even though nothing of either survives
+    // compilation. Assert that NO file on the graph has a value import — not
+    // just the conf. That is the claim in the title, and it is what keeps
+    // `--help`/`__complete`/`--version` free of module-init work when another
+    // lane or a fork edits any of these three (`packs/types.ts` in particular
+    // is the grammar that type-checks the declared stories, and its own
+    // docblock promises it stays zod-free BECAUSE it lands here).
+    const graph = [...staticImportGraph(conf)];
+    for (const file of graph) {
+      expect(readFileSync(file, "utf-8"), file).not.toMatch(
+        /^import (?!type\b)/m,
+      );
+    }
+    // The enumeration is exact, not a subset: a type import from a module that
+    // itself imports something grows this list and fails here.
+    expect(graph.map((f) => relative(pkgRoot, f)).sort()).toEqual([
+      "pragma.conf.ts",
+      "src/kernel/config/types.ts",
+      "src/kernel/packs/types.ts",
+    ]);
+  });
+
+  it("the dispatch path never reaches the embedded n-quads module (PROTECTED)", () => {
+    // `activeStories` reads the pack's carried stories from their OWN generated
+    // module rather than through `graphpack/embedded.ts`, which statically
+    // imports the ~1.9 MB `pack.generated.ts`. Restoring that edge costs a
+    // measured +23 ms on EVERY dispatched command, and the whole test suite
+    // passes with it restored — the split is prose in three docblocks and
+    // nothing else. This is the constraint those docblocks describe.
+    for (const entry of [
+      "../kernel/packs/collect.ts",
+      "../kernel/runtime/graphpack/stories.ts",
+      "../kernel/runtime/resolveSources.ts",
+    ]) {
+      const graph = staticImportGraph(resolve(here, entry));
+      expect(has(graph, "embedded/pack.generated.ts"), entry).toBe(false);
+      expect(has(graph, "graphpack/embedded.ts"), entry).toBe(false);
+    }
   });
 
   it("the help path (buildProgram) imports no zod schema module", () => {
@@ -86,4 +139,74 @@ describe("lazy dispatch — module-graph probe (PROTECTED)", () => {
       }
     }
   });
+
+  // The create surface's registration machinery — summon-core's projection
+  // helpers, its Commander adapter, and Commander itself — must stay behind
+  // the mount's dynamic import: `--help` and `__complete` both import this
+  // barrel and neither registers a single create command, so an eager edge
+  // here taxes every fast-path spawn for work only a dispatched `create`
+  // invocation performs. The registered flag/positional spellings the fast
+  // paths DO need (completion tokens, reference syntax) are baked into
+  // `createSurface.generated.ts` at build time, so nothing on this graph has
+  // to call the projection to learn them. Type-only imports are allowed —
+  // they are erased — which is why this walks import STATEMENTS rather than
+  // grepping for the specifier.
+  it("capabilities/index pulls no summon-core projection, adapter, or commander value import (PROTECTED)", () => {
+    const banned = [/^@canonical\/summon-core\/projection/, /^commander$/];
+    const graph = staticImportGraph(resolve(here, "index.ts"));
+    const pkgRoot = resolve(here, "..", "..");
+    // Anchored to line start so the word "import" inside a docblock cannot
+    // open a match that swallows prose down to the next real specifier.
+    const importRe = /^import\s+([^;]*?)from\s*["']([^"']+)["']/gm;
+    const offenders: string[] = [];
+    for (const file of graph) {
+      const source = readFileSync(file, "utf-8");
+      for (const match of source.matchAll(importRe)) {
+        const clause = match[1] as string;
+        const specifier = match[2] as string;
+        if (!banned.some((re) => re.test(specifier))) continue;
+        if (/^type\s/.test(clause.trim())) continue;
+        offenders.push(`${relative(pkgRoot, file)} → ${specifier}`);
+      }
+    }
+    expect(offenders).toEqual([]);
+  });
+
+  it("NO module on that graph statically imports zod (PROTECTED)", () => {
+    // This used to pin an exact set of one — `graphpack/types.ts`, reached via
+    // `resolveSources` → `packIsComplete` → `readManifest` → `manifestSchema
+    // .parse` — as the one genuine zod value import on the storeless graph,
+    // measured at ~3–4 ms of a ~30 ms budget. Its own comment said an exact set
+    // was what would make the day it got fixed impossible to miss. That day is
+    // this commit: the schemas moved to `graphpack/schemas.ts`, imported only by
+    // the two readers already off the fast path, and `readManifest` validates
+    // structurally instead.
+    //
+    // The set is now EMPTY, which is strictly stronger than the pin it replaces:
+    // it no longer tolerates one named module, so a brand-new module value-
+    // importing zod fails here too — the gap the previous form left open.
+    const graph = staticImportGraph(resolve(here, "index.ts"));
+    const pkgRoot = resolve(here, "..", "..");
+    const zodImporters = [...graph]
+      .filter((file) => /from\s*["']zod["']/.test(readFileSync(file, "utf-8")))
+      .map((file) => relative(pkgRoot, file))
+      .sort();
+    expect(zodImporters).toEqual([]);
+  });
+
+  it("the help path (buildProgram) imports zod from nowhere (PROTECTED)", () => {
+    // The named-module check above (`kernel/config/schema.ts`,
+    // `kernel/spec/validate.ts`) could only catch the two modules it names — a
+    // third zod importer reaching the help path would have passed it silently.
+    // Generalized (ruling R4) to the property those names were standing in for.
+    const graph = staticImportGraph(
+      resolve(here, "../kernel/project/cli/buildProgram.ts"),
+    );
+    const pkgRoot = resolve(here, "..", "..");
+    const zodImporters = [...graph]
+      .filter((file) => /from\s*["']zod["']/.test(readFileSync(file, "utf-8")))
+      .map((file) => relative(pkgRoot, file))
+      .sort();
+    expect(zodImporters).toEqual([]);
+  });
 });

package/src/capabilities/meta/complete.verb.ts

@@ -10,7 +10,7 @@
  * Storeless: the entity tier reads the index off disk, never booting the store.
  */
 
-import type { VerbSpec } from "../../kernel/spec/types.js";
+import type { VerbSpec } from "../../kernel/spec/index.js";
 
 /** The `__complete` verb spec. */
 export const completeVerb: VerbSpec<Record<string, unknown>, string[]> = {

package/src/capabilities/meta/index.ts

@@ -4,7 +4,7 @@
  */
 
 import { asVerb } from "../../kernel/spec/asVerb.js";
-import type { CapabilityModule } from "../../kernel/spec/types.js";
+import type { CapabilityModule } from "../../kernel/spec/index.js";
 import { completeVerb } from "./complete.verb.js";
 import { mcpVerb } from "./mcp.verb.js";
 

package/src/capabilities/meta/mcp.verb.ts

@@ -1,19 +1,21 @@
 /**
- * The hidden `mcp` verb — the MCP server entry point.
+ * `mcp serve` — the MCP server entry point.
  *
- * The server is not an agent tool, so it is withheld from MCP with a reason and
- * `hidden` from the CLI surface/help. The bin special-cases `pragma mcp` to
- * serve over stdio (D9); this spec's lazy `run` is the same serve, reachable if
- * a future tier dispatches it.
+ * The server is not an agent tool, so it is withheld from MCP with a reason —
+ * but it IS a command, and it is spelled like one: a noun and a verb, the same
+ * shape as every other pair in the grammar, so it completes, appears in help,
+ * and answers `--help` without a special case. The bin still short-circuits
+ * the exact `pragma mcp serve` invocation before flag parsing and first-run,
+ * because the server's stdout carries JSON-RPC and nothing else may reach it;
+ * this spec's lazy `run` is that same serve, for any tier that dispatches it.
  */
 
-import type { VerbSpec } from "../../kernel/spec/types.js";
+import type { VerbSpec } from "../../kernel/spec/index.js";
 
 /** The `mcp` verb spec. */
 export const mcpVerb: VerbSpec<Record<string, unknown>, void> = {
-  path: ["mcp"],
+  path: ["mcp", "serve"],
   summary: "Start the MCP server over stdio.",
-  hidden: true,
   params: [],
   output: {
     formatters: {

package/src/capabilities/ontology/index.ts

@@ -2,18 +2,22 @@
  * The `ontology` capability module — schema (TBox) inspection.
  */
 
-import type { CapabilityModule } from "../../kernel/spec/types.js";
-import {
-  ontologyListVerb,
-  ontologyLookupVerb,
-  ontologyShowVerb,
-} from "./verbs.js";
+import type { CapabilityModule } from "../../kernel/spec/index.js";
+import { ontologyListVerb, ontologyLookupVerb } from "./verbs.js";
 
-/**
- * The `ontology` capability module (`list`, `lookup`, and the deprecated `show`
- * alias — AV-228 B1).
- */
+/** The `ontology` capability module (`list` and the `lookup` by-name read). */
 export const ontologyModule: CapabilityModule = {
   name: "ontology",
-  verbs: [ontologyListVerb, ontologyLookupVerb, ontologyShowVerb],
+  verbs: [ontologyListVerb, ontologyLookupVerb],
+  /**
+   * The ONE hand-declared listing in the distribution. Every other module is
+   * story-compiled and has its slice DERIVED from the types its lookup already
+   * names; this noun addresses the schema itself, which no `type` filter
+   * expresses — the whole TBox is the answer, so it is stated once, here.
+   *
+   * `0.5` puts the schema below the story collections (weight 1) it explains
+   * and above nothing else: an agent orienting itself wants the collections
+   * first, then the vocabulary they are described in.
+   */
+  mcpListable: { sources: [{ box: "tbox", as: "entities", weight: 0.5 }] },
 };

package/src/capabilities/ontology/ontology.test.ts

@@ -1,5 +1,5 @@
 /**
- * Ontology inspection (list + show) over the block fixture graph.
+ * Ontology inspection (list + lookup) over the block fixture graph.
  *
  * Asserts the TBox exception: namespaces are grouped with class/property counts,
  * a namespace's class hierarchy carries per-class instance counts from the pack
@@ -32,10 +32,6 @@ const listVerb = ontologyModule.verbs.find(
 const lookupVerb = ontologyModule.verbs.find(
   (v) => verbKey(v.path) === "ontology lookup",
 ) as VerbSpec;
-const showVerb = ontologyModule.verbs.find(
-  (v) => verbKey(v.path) === "ontology show",
-) as VerbSpec;
-
 let rt: PragmaRuntime;
 beforeAll(async () => {
   ({ rt } = await buildFixtureRuntime({
@@ -132,36 +128,11 @@ describe("ontology lookup (primary by-name read)", () => {
   });
 });
 
-describe("ontology show — deprecated alias of lookup (AV-228 B1)", () => {
-  it("is marked deprecated in its summary and steers callers to `ontology lookup`", () => {
-    expect(showVerb.summary.toLowerCase()).toContain("deprecated");
-    expect(showVerb.summary).toContain("ontology lookup");
-  });
-
-  it("shares the lookup handler — same payload for the same input", async () => {
-    const viaLookup = (await lookupVerb.run(
-      { prefix: "ds", properties: true },
-      rt,
-    )) as OntologyShowData;
-    const viaShow = (await showVerb.run(
-      { prefix: "ds", properties: true },
-      rt,
-    )) as OntologyShowData;
-    expect(viaShow).toEqual(viaLookup);
-  });
-
-  it("still rejects an unknown prefix (the alias is a full, callable verb)", async () => {
-    await expect(showVerb.run({ prefix: "nope" }, rt)).rejects.toThrow(
-      /prefix/i,
-    );
-  });
-});
-
-describe("ontology_show honours detail over MCP (B5)", () => {
-  // The CLI B5 cases above seed `globalFlags.detail` and call `showVerb.run`
+describe("ontology_lookup honours detail over MCP (B5)", () => {
+  // The CLI B5 cases above seed `globalFlags.detail` and call `lookupVerb.run`
   // directly. Over MCP there are NO global flags — the ONLY detail channel is
   // the per-tool `detail` param the projector injects from the VerbSpec
-  // disclosure. Under an AMBIENT config `detail: standard`, an `ontology_show`
+  // disclosure. Under an AMBIENT config `detail: standard`, a by-name read
   // with no declared disclosure would force the properties section with no
   // per-call escape (the AV-228 MCP-opt-out asymmetry `block`/`standard` lack);
   // declaring disclosure lights the param up, so an agent can ask for
@@ -184,15 +155,6 @@ describe("ontology_show honours detail over MCP (B5)", () => {
     await fixture.dispose();
   });
 
-  it("injects a detail param onto the ontology_show tool (symmetric with block/standard)", async () => {
-    const tools = await mcp.listTools();
-    const show = tools.find((t) => t.name === "ontology_show");
-    const schema = show?.inputSchema as {
-      properties?: Record<string, unknown>;
-    };
-    expect(schema.properties?.detail).toBeDefined();
-  });
-
   it("exposes the primary ontology_lookup tool with the same injected detail param (AV-228 B1)", async () => {
     const tools = await mcp.listTools();
     const lookup = tools.find((t) => t.name === "ontology_lookup");
@@ -217,25 +179,14 @@ describe("ontology_show honours detail over MCP (B5)", () => {
   it("honours the ambient detail=standard config when no per-call detail is set", async () => {
     // Proves the ambient level really is standard, so the summary case below is
     // a genuine per-call override rather than merely the spec default.
-    const result = await mcp.callTool("ontology_show", { prefix: "ds" });
+    const result = await mcp.callTool("ontology_lookup", { prefix: "ds" });
     expect(result.ok).toBe(true);
     const data = result.data as { properties: unknown[] };
     expect(data.properties.length).toBeGreaterThan(0);
   });
 
-  it("a per-call detail=summary returns classes-only despite the ambient standard", async () => {
-    const result = await mcp.callTool("ontology_show", {
-      prefix: "ds",
-      detail: "summary",
-    });
-    expect(result.ok).toBe(true);
-    const data = result.data as { classes: unknown[]; properties: unknown[] };
-    expect(data.classes.length).toBeGreaterThan(0);
-    expect(data.properties).toEqual([]);
-  });
-
   it("an explicit detail=detailed overrides upward to include properties", async () => {
-    const result = await mcp.callTool("ontology_show", {
+    const result = await mcp.callTool("ontology_lookup", {
       prefix: "ds",
       detail: "detailed",
     });

package/src/capabilities/ontology/queries.ts

@@ -7,7 +7,7 @@
  * result never depends on which vocabulary prefixes the store injected.
  */
 
-import type { PragmaRuntime } from "../../kernel/runtime/types.js";
+import type { PragmaRuntime } from "../../kernel/runtime/index.js";
 
 const OWL = "http://www.w3.org/2002/07/owl#";
 const RDFS = "http://www.w3.org/2000/01/rdf-schema#";
@@ -40,7 +40,7 @@ export interface OntologyProperty {
   readonly type: "object" | "datatype";
 }
 
-/** The `ontology show` payload — the detailed view plus render options. */
+/** The `ontology lookup` payload — the detailed view plus render options. */
 export interface OntologyShowData {
   readonly prefix: string;
   readonly namespace: string;

package/src/capabilities/ontology/render.ts

@@ -1,10 +1,9 @@
 /**
- * Formatters for `ontology list` and `ontology show`.
+ * Formatters for `ontology list` and `ontology lookup`.
  */
 
-import { compactUri } from "../../kernel/render/compactUri.js";
-import { DEFAULT_PREFIX_MAP } from "../../kernel/render/prefixes.js";
-import type { Formatters } from "../../kernel/spec/types.js";
+import { compactUri, DEFAULT_PREFIX_MAP } from "../../kernel/render/index.js";
+import type { Formatters } from "../../kernel/spec/index.js";
 import type {
   OntologyClass,
   OntologyProperty,