@canonical/pragma-cli 0.29.0 → 0.31.0

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.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { ontologyListStory, ontologyShowStory } from "./stories.js";
+
+describe("ontologyListStory", () => {
+  it("renders the ink list view", () => {
+    const view = ontologyListStory.renderInk?.([]);
+    expect(typeof view).toBe("string");
+    expect(view).toContain("Ontologies");
+  });
+
+  it("rejects only empty results", () => {
+    expect(ontologyListStory.emptyError?.([], {})).toBeDefined();
+    expect(
+      ontologyListStory.emptyError?.(
+        [
+          {
+            prefix: "ds",
+            namespace: "https://ds.example/",
+            classCount: 1,
+            propertyCount: 1,
+            anatomyCount: 0,
+          },
+        ],
+        {},
+      ),
+    ).toBeUndefined();
+  });
+});
+
+describe("ontologyShowStory", () => {
+  it("guards against a missing prefix", () => {
+    expect(ontologyShowStory.guardParams?.({})).toBeDefined();
+    expect(ontologyShowStory.guardParams?.({ prefix: "" })).toBeDefined();
+    expect(ontologyShowStory.guardParams?.({ prefix: "ds" })).toBeUndefined();
+  });
+});

package/src/domains/ontology/stories.ts

@@ -0,0 +1,153 @@
+/**
+ * Ontology read stories — the single declaration of `ontology list` and
+ * `ontology show` for both surfaces.
+ *
+ * The story kernel compiles these into the CLI commands and MCP tools.
+ * Both surfaces now render through the same formatters, so MCP condensed
+ * output matches CLI `--llm` output by construction (previously the MCP
+ * specs re-implemented the Markdown inline and had drifted).
+ */
+
+import { PragmaError } from "#error";
+import { createListView } from "#tui";
+import type { ColumnDef } from "../shared/contracts.js";
+import {
+  type ReadStory,
+  requirePragmaContext,
+} from "../shared/stories/index.js";
+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: "relationCount", label: "Relations" },
+  { key: "attributeCount", label: "Attributes" },
+  { key: "shapeCount", label: "Shapes" },
+];
+
+/** The `ontology list` / `ontology_list` read story. */
+export const ontologyListStory: ReadStory<
+  OntologySummary[],
+  readonly OntologySummary[]
+> = {
+  noun: "ontology",
+  verb: "list",
+  description: "List loaded ontologies",
+  toolDescription:
+    "List all ontologies loaded in the knowledge graph with class and property counts.",
+  params: [],
+  examples: ["pragma ontology list", "pragma ontology list --llm"],
+  resolve: (rt) => listOntologies(rt.store),
+  toOutput: (ontologies) => ontologies,
+  formatters: listFormatters,
+  toEnvelope: (ontologies) => ({
+    data: ontologies,
+    meta: { count: ontologies.length },
+  }),
+  emptyError: (ontologies) =>
+    ontologies.length === 0
+      ? PragmaError.emptyResults("ontology", {
+          recovery: {
+            message: "Ensure design system packages are installed.",
+          },
+        })
+      : undefined,
+  renderInk: (ontologies) =>
+    createListView({
+      heading: "Ontologies",
+      domain: "ontology",
+      items: ontologies,
+      columns: ontologyListColumns,
+    }),
+};
+
+/** The `ontology show <prefix>` / `ontology_show` read story. */
+export const ontologyShowStory: ReadStory<OntologyDetailed, OntologyShowInput> =
+  {
+    noun: "ontology",
+    verb: "show",
+    description: "Show ontology schema details",
+    toolDescription:
+      "Show the TBox for a namespace: class hierarchy with instance counts and relations, plus metadata and constraints.",
+    params: [
+      {
+        name: "prefix",
+        type: "string",
+        description: "Ontology prefix (e.g. 'ds', 'cs')",
+        positional: true,
+        required: true,
+        complete: async (partial, cmdCtx) => {
+          const ctx = requirePragmaContext(cmdCtx);
+          const all = await listOntologies(ctx.store);
+          return all
+            .map((o) => o.prefix)
+            .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",
+    ],
+    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) =>
+      typeof params.prefix === "string" && params.prefix.length > 0
+        ? undefined
+        : PragmaError.invalidInput("prefix", "(empty)", {
+            recovery: {
+              message: "List loaded ontologies to find valid prefixes.",
+              cli: "pragma ontology list",
+              mcp: { tool: "ontology_list" },
+            },
+          }),
+  };

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

@@ -8,12 +8,10 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { readConfig } from "#config";
-import { DEFAULT_PACKAGES } from "../../shared/packages.js";
+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";
-import readGlobalRefs from "./readGlobalRefs.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -56,7 +54,7 @@ export default async function updateRefs(
   options: UpdateRefsOptions,
 ): Promise<UpdateResult[]> {
   const config = readConfig(options.cwd);
-  const refs = mergeEntries(config.packages);
+  const refs = mergeAndParseRefs(config.packages);
   const results: UpdateResult[] = [];
 
   for (const ref of refs) {
@@ -137,40 +135,6 @@ export default async function updateRefs(
 // Helpers
 // ---------------------------------------------------------------------------
 
-/** Merge global + project entries, parse into PackageRef[]. */
-function mergeEntries(
-  projectPackages?: ReadonlyArray<RawPackageEntry>,
-): PackageRef[] {
-  const globalEntries = readGlobalRefs();
-
-  if (
-    (!projectPackages || projectPackages.length === 0) &&
-    globalEntries.length === 0
-  ) {
-    return DEFAULT_PACKAGES.map((pkg) => parsePackageEntry(pkg));
-  }
-
-  const merged = new Map<string, RawPackageEntry>();
-
-  for (const entry of DEFAULT_PACKAGES) {
-    const name = typeof entry === "string" ? entry : entry.name;
-    merged.set(name, entry);
-  }
-  for (const entry of globalEntries) {
-    const name = typeof entry === "string" ? entry : entry.name;
-    merged.set(name, entry);
-  }
-  if (projectPackages) {
-    merged.clear();
-    for (const entry of projectPackages) {
-      const name = typeof entry === "string" ? entry : entry.name;
-      merged.set(name, entry);
-    }
-  }
-
-  return [...merged.values()].map(parsePackageEntry);
-}
-
 /**
  * Remove cache directories that don't match any configured git ref.
  * Returns list of removed directories.

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";

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

@@ -0,0 +1,70 @@
+/**
+ * Wires the top-level `pragma setup` command.
+ *
+ * `setup` is one level more general than `create <thing>`: it configures the
+ * whole local environment (completions, LSP, MCP). Unlike `create`, its steps
+ * perform *read* effects whose results drive control flow — detecting AI
+ * harnesses, checking what is already installed — so it must run for real and
+ * report the real outcome. It therefore executes through {@link runSetupTask}
+ * (real execution, streamed output) rather than the generator preview-then-
+ * execute path, which would render a dry-run preview whose stubbed reads report
+ * the wrong state (e.g. "no harnesses detected").
+ */
+
+import type { CommandDefinition, CommandResult } from "@canonical/cli-core";
+import runSetupTask from "../helpers/runSetupTask.js";
+import setupAll from "../operations/setupAll.js";
+
+/**
+ * Build the top-level `pragma setup` command definition.
+ *
+ * @returns The command definition for `pragma setup`.
+ * @note Impure
+ */
+export default function buildSetupCommand(): CommandDefinition {
+  return {
+    path: ["setup"],
+    description:
+      "Configure this project's environment: completions, LSP, and MCP",
+    parameters: [
+      {
+        name: "dryRun",
+        description: "Preview changes without writing",
+        type: "boolean",
+        default: false,
+      },
+      {
+        name: "undo",
+        description: "Reverse a previous setup",
+        type: "boolean",
+        default: false,
+      },
+      {
+        name: "yes",
+        description: "Skip all confirmation prompts",
+        type: "boolean",
+        default: false,
+      },
+    ],
+    meta: {
+      examples: [
+        "pragma setup",
+        "pragma setup --yes",
+        "pragma setup --dry-run",
+        "pragma setup --undo",
+      ],
+    },
+    execute: async (
+      params: Record<string, unknown>,
+      ctx,
+    ): Promise<CommandResult> =>
+      runSetupTask(setupAll(ctx.cwd), {
+        dryRun: params.dryRun === true,
+        undo: params.undo === true,
+        yes: params.yes === true,
+        verbose: ctx.globalFlags.verbose,
+        llm: ctx.globalFlags.llm,
+        format: ctx.globalFlags.format,
+      }),
+  };
+}