@canonical/pragma-cli 0.20.0 → 0.22.0-experimental.0

package/src/domains/ontology/formatters/show.ts

@@ -1,7 +1,9 @@
 import chalk from "chalk";
 import { formatHeading, formatSection } from "#pipeline";
+import compactUri from "../../shared/compactUri.js";
 import type { Formatters } from "../../shared/formatters.js";
-import type { OntologyDetailed } from "../../shared/types.js";
+import { PREFIX_MAP } from "../../shared/prefixes.js";
+import type { OntologyDetailed } from "../../shared/types/index.js";
 
 /**
  * Formatters for `pragma ontology show` output.
@@ -14,13 +16,19 @@ const formatters: Formatters<OntologyDetailed> = {
   plain(data) {
     const lines: string[] = [];
 
-    lines.push(formatHeading(`${data.prefix}: (${data.namespace})`));
+    lines.push(
+      formatHeading(
+        `${data.prefix}: ${compactUri(data.namespace, PREFIX_MAP)}`,
+      ),
+    );
 
     if (data.classes.length > 0) {
       const classLines = data.classes
         .map((c) => {
-          const sup = c.superclass ? chalk.dim(` extends ${c.superclass}`) : "";
-          return `  ${chalk.bold(c.label)}${sup}`;
+          const sup = c.superclass
+            ? chalk.dim(` extends ${compactUri(c.superclass, PREFIX_MAP)}`)
+            : "";
+          return `  ${chalk.bold(c.label)} ${chalk.dim(`(${compactUri(c.uri, PREFIX_MAP)})`)}${sup}`;
         })
         .join("\n");
       lines.push("");
@@ -30,9 +38,13 @@ const formatters: Formatters<OntologyDetailed> = {
     if (data.properties.length > 0) {
       const propLines = data.properties
         .map((p) => {
-          const domain = p.domain ? chalk.dim(` domain: ${p.domain}`) : "";
-          const range = p.range ? chalk.dim(` range: ${p.range}`) : "";
-          return `  ${chalk.bold(p.label)} (${p.type})${domain}${range}`;
+          const domain = p.domain
+            ? chalk.dim(` domain: ${compactUri(p.domain, PREFIX_MAP)}`)
+            : "";
+          const range = p.range
+            ? chalk.dim(` range: ${compactUri(p.range, PREFIX_MAP)}`)
+            : "";
+          return `  ${chalk.bold(p.label)} ${chalk.dim(`(${compactUri(p.uri, PREFIX_MAP)})`)} (${p.type})${domain}${range}`;
         })
         .join("\n");
       lines.push("");
@@ -43,13 +55,20 @@ const formatters: Formatters<OntologyDetailed> = {
   },
 
   llm(data) {
-    const lines = [`## ${data.prefix}: (${data.namespace})`, ""];
+    const lines = [
+      `## ${data.prefix}: ${compactUri(data.namespace, PREFIX_MAP)}`,
+      "",
+    ];
 
     if (data.classes.length > 0) {
       lines.push("### Classes");
       for (const c of data.classes) {
-        const sup = c.superclass ? ` extends ${c.superclass}` : "";
-        lines.push(`- **${c.label}**${sup}`);
+        const sup = c.superclass
+          ? ` extends ${compactUri(c.superclass, PREFIX_MAP)}`
+          : "";
+        lines.push(
+          `- \`${compactUri(c.uri, PREFIX_MAP)}\` — **${c.label}**${sup}`,
+        );
       }
       lines.push("");
     }
@@ -57,9 +76,15 @@ const formatters: Formatters<OntologyDetailed> = {
     if (data.properties.length > 0) {
       lines.push("### Properties");
       for (const p of data.properties) {
-        const domain = p.domain ? ` domain: ${p.domain}` : "";
-        const range = p.range ? ` range: ${p.range}` : "";
-        lines.push(`- **${p.label}** (${p.type})${domain}${range}`);
+        const domain = p.domain
+          ? ` domain: ${compactUri(p.domain, PREFIX_MAP)}`
+          : "";
+        const range = p.range
+          ? ` range: ${compactUri(p.range, PREFIX_MAP)}`
+          : "";
+        lines.push(
+          `- \`${compactUri(p.uri, PREFIX_MAP)}\` — **${p.label}** (${p.type})${domain}${range}`,
+        );
       }
     }
 

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

@@ -2,7 +2,7 @@ import type { Store } from "@canonical/ke";
 import { buildQuery } from "../../shared/buildQuery.js";
 import extractLocalName from "../../shared/extractLocalName.js";
 import { P } from "../../shared/prefixes.js";
-import type { OntologyClass } from "../../shared/types.js";
+import type { OntologyClass } from "../../shared/types/index.js";
 
 /**
  * Queries all `owl:Class` definitions within a namespace.

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

@@ -2,7 +2,7 @@ import type { Store } from "@canonical/ke";
 import { buildQuery } from "../../shared/buildQuery.js";
 import extractLocalName from "../../shared/extractLocalName.js";
 import { P } from "../../shared/prefixes.js";
-import type { OntologyProperty } from "../../shared/types.js";
+import type { OntologyProperty } from "../../shared/types/index.js";
 
 /**
  * Queries all `owl:ObjectProperty` and `owl:DatatypeProperty` definitions

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

@@ -1,7 +1,7 @@
 import type { Store } from "@canonical/ke";
 import { buildQuery } from "../../shared/buildQuery.js";
 import { P } from "../../shared/prefixes.js";
-import type { OntologySummary } from "../../shared/types.js";
+import type { OntologySummary } from "../../shared/types/index.js";
 import findNamespace from "../helpers/findNamespace.js";
 
 /** Check whether a URI belongs to the anatomy namespace. */

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

@@ -1,6 +1,6 @@
 import type { Store } from "@canonical/ke";
 import { PragmaError } from "#error";
-import type { OntologyDetailed } from "../../shared/types.js";
+import type { OntologyDetailed } from "../../shared/types/index.js";
 import queryClasses from "../helpers/queryClasses.js";
 import queryProperties from "../helpers/queryProperties.js";
 import resolvePrefix from "../helpers/resolvePrefix.js";

package/src/domains/setup/helpers/completionScripts.test.ts

@@ -9,19 +9,19 @@ describe("completionScriptContent", () => {
   it("produces zsh completion with compdef", () => {
     const script = completionScriptContent("zsh");
     expect(script).toContain("#compdef pragma");
-    expect(script).toContain("pragma completions zsh");
+    expect(script).toContain("pragma --completions");
   });
 
   it("produces bash completion with complete -F", () => {
     const script = completionScriptContent("bash");
     expect(script).toContain("complete -F _pragma pragma");
-    expect(script).toContain("pragma completions bash");
+    expect(script).toContain("pragma --completions");
   });
 
   it("produces fish completion with complete -c", () => {
     const script = completionScriptContent("fish");
     expect(script).toContain("complete -c pragma");
-    expect(script).toContain("pragma completions fish");
+    expect(script).toContain("pragma --completions");
   });
 });
 

package/src/domains/setup/helpers/completionScripts.ts

@@ -5,7 +5,7 @@ const HOME = process.env.HOME ?? "";
 /**
  * Generate the shell-specific completion script content.
  *
- * Each script delegates to `pragma completions <shell>` at runtime
+ * Each script delegates to `pragma --completions` at runtime
  * so the completion logic stays in the CLI, not in the shell script.
  *
  * @param shell - Target shell identifier.
@@ -21,7 +21,7 @@ export function completionScriptContent(shell: ShellId): string {
         "_pragma() {",
         "  local -a completions",
         // biome-ignore lint/suspicious/noTemplateCurlyInString: shell syntax, not JS template
-        '  completions=("${(@f)$(pragma completions zsh -- "${words[@]}" 2>/dev/null)}")',
+        '  completions=("${(@f)$(pragma --completions "${words[@]}" 2>/dev/null)}")',
         "  compadd -- $completions",
         "}",
         "",
@@ -38,7 +38,7 @@ export function completionScriptContent(shell: ShellId): string {
         '  local cur="${COMP_WORDS[COMP_CWORD]}"',
         "  local completions",
         // biome-ignore lint/suspicious/noTemplateCurlyInString: shell syntax, not JS template
-        '  completions=$(pragma completions bash -- "${COMP_WORDS[@]}" 2>/dev/null)',
+        '  completions=$(pragma --completions "${COMP_WORDS[@]}" 2>/dev/null)',
         "  # shellcheck disable=SC2207",
         '  COMPREPLY=($(compgen -W "$completions" -- "$cur"))',
         "}",
@@ -51,7 +51,7 @@ export function completionScriptContent(shell: ShellId): string {
       return [
         "# Generated by `pragma setup completions`",
         "",
-        "complete -c pragma -f -a '(pragma completions fish -- (commandline -cop) 2>/dev/null)'",
+        "complete -c pragma -f -a '(pragma --completions (commandline -cop) 2>/dev/null)'",
         "",
       ].join("\n");
   }

package/src/domains/shared/ToolSpec.ts

@@ -6,7 +6,7 @@
  * envelopes, and `server.registerTool()` calls.
  */
 
-import type { PragmaRuntime } from "./runtime.js";
+import type { PragmaRuntime } from "./types/index.js";
 
 /**
  * Parameter definition for a tool — neutral format.

package/src/domains/shared/context.ts

@@ -7,9 +7,10 @@
  * cli-core remains unaware of Store or FilterConfig.
  */
 
-import type { GlobalFlags } from "@canonical/cli-core";
-import type { PragmaRuntime } from "./runtime.js";
+import type { GlobalFlags, InteractiveHandler } from "@canonical/cli-core";
+import type { PragmaRuntime } from "./types/index.js";
 
 export interface PragmaContext extends PragmaRuntime {
   readonly globalFlags: GlobalFlags;
+  readonly interactive?: InteractiveHandler | undefined;
 }

package/src/domains/shared/contracts.ts

@@ -4,7 +4,7 @@
  * These types provide the structural common ground for CLI and MCP surfaces.
  */
 
-import type { FilterConfig } from "./types.js";
+import type { FilterConfig } from "./types/index.js";
 
 export interface ColumnDef<T> {
   readonly key: keyof T & string;
@@ -83,6 +83,45 @@ export interface LookupContract<TDetailed> {
   readonly result: LookupResult<TDetailed>;
 }
 
+// ---------------------------------------------------------------------------
+// Renderer contracts
+// ---------------------------------------------------------------------------
+
+/** A single inline field rendered in a lookup heading block. */
+export interface LookupField<T> {
+  readonly label: string;
+  readonly value: (entity: T) => unknown;
+}
+
+/** Per-mode override callbacks for a lookup section. */
+export interface LookupSectionOverride<T> {
+  readonly plain?: (entity: T, section: SectionDef<T>) => string | null;
+  readonly llm?: (entity: T, section: SectionDef<T>) => string | null;
+}
+
+/** Options controlling the generic list renderer. */
+export interface RenderListOptions<T> {
+  readonly heading: string;
+  readonly columns: readonly ColumnDef<T>[];
+  readonly prefixes?: Readonly<Record<string, string>>;
+}
+
+/** Options controlling the generic lookup renderer. */
+export interface RenderLookupOptions<T> {
+  readonly title: (entity: T) => string;
+  readonly fields: readonly LookupField<T>[];
+  readonly sections: readonly SectionDef<T>[];
+  readonly prefixes?: Readonly<Record<string, string>>;
+  readonly sectionOverrides?: Partial<
+    Record<keyof T & string, LookupSectionOverride<T>>
+  >;
+  readonly codeLanguage?: (section: SectionDef<T>, value: unknown) => string;
+}
+
+// ---------------------------------------------------------------------------
+// Entity display configuration
+// ---------------------------------------------------------------------------
+
 export interface EntityDisplayConfig<
   TSummary,
   TDigest extends TSummary,

package/src/domains/shared/filters/buildFilterConfig.ts

@@ -2,8 +2,7 @@
  * Build a FilterConfig from runtime config, optionally widening tier.
  */
 
-import type { PragmaRuntime } from "../runtime.js";
-import type { FilterConfig } from "../types.js";
+import type { FilterConfig, PragmaRuntime } from "../types/index.js";
 
 export default function buildFilterConfig(
   runtime: PragmaRuntime,

package/src/domains/shared/filters/buildFilters.ts

@@ -4,7 +4,7 @@
  * Both tier and channel filters apply simultaneously as AND constraints.
  */
 
-import type { FilterConfig } from "../types.js";
+import type { FilterConfig } from "../types/index.js";
 import { buildChannelFilter } from "./buildChannelFilter.js";
 import { buildTierFilter } from "./buildTierFilter.js";
 

package/src/domains/shared/filters/describeFilters.ts

@@ -2,7 +2,7 @@
  * Describe active filters as human-readable key-value pairs.
  */
 
-import type { FilterConfig } from "../types.js";
+import type { FilterConfig } from "../types/index.js";
 
 export default function describeFilters(
   filters: FilterConfig,

package/src/domains/shared/formatters.ts

@@ -8,6 +8,7 @@
  */
 
 import type { CommandContext } from "@canonical/cli-core";
+import type { LookupResult } from "./contracts.js";
 
 /**
  * The three output modes every command must support.
@@ -20,6 +21,13 @@ export interface Formatters<T> {
   readonly json: (data: T) => string;
 }
 
+interface RenderLookupResultsOptions<TResult, TInput> {
+  readonly ctx: CommandContext;
+  readonly result: LookupResult<TResult>;
+  readonly formatters: Formatters<TInput>;
+  readonly mapResult: (item: TResult) => TInput;
+}
+
 /**
  * Pick the right formatter based on global flags.
  *
@@ -33,3 +41,42 @@ export function selectFormatter<T>(
   if (ctx.globalFlags.llm) return formatters.llm;
   return formatters.plain;
 }
+
+export function renderLookupResults<TResult, TInput>(
+  options: RenderLookupResultsOptions<TResult, TInput>,
+): string {
+  const { ctx, result, formatters, mapResult } = options;
+  const formatOne = selectFormatter(ctx, formatters);
+
+  if (ctx.globalFlags.format === "json") {
+    if (result.results.length === 1 && result.errors.length === 0) {
+      const only = result.results[0];
+      return only
+        ? formatters.json(mapResult(only))
+        : JSON.stringify({ results: [], errors: result.errors }, null, 2);
+    }
+
+    return JSON.stringify(
+      {
+        results: result.results.map((item) =>
+          JSON.parse(formatters.json(mapResult(item))),
+        ),
+        errors: result.errors,
+      },
+      null,
+      2,
+    );
+  }
+
+  const parts = result.results.map((item) => formatOne(mapResult(item)));
+  if (result.errors.length > 0) {
+    parts.push(
+      [
+        "Errors:",
+        ...result.errors.map((error) => `- ${error.query}: ${error.message}`),
+      ].join("\n"),
+    );
+  }
+
+  return parts.join("\n\n");
+}