@canonical/pragma-cli 0.30.0 → 0.31.0

package/src/domains/block/formatters/list.test.ts

@@ -1,11 +1,11 @@
 import type { URI } from "@canonical/ke";
 import { describe, expect, it } from "vitest";
-import { PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
 import type { BlockSummary } from "../../shared/types/index.js";
 import formatters from "./list.js";
 
 const BUTTON: BlockSummary = {
-  uri: `${PREFIX_MAP.ds}button` as URI,
+  uri: `${DEFAULT_PREFIX_MAP.ds}button` as URI,
   name: "Button",
   tier: "global",
   modifiers: ["importance", "density"],
@@ -18,7 +18,7 @@ const BUTTON: BlockSummary = {
 };
 
 const CARD: BlockSummary = {
-  uri: `${PREFIX_MAP.ds}card` as URI,
+  uri: `${DEFAULT_PREFIX_MAP.ds}card` as URI,
   name: "Card",
   tier: "global",
   modifiers: [],

package/src/domains/block/formatters/lookup.test.ts

@@ -1,12 +1,12 @@
 import type { URI } from "@canonical/ke";
 import { describe, expect, it } from "vitest";
-import { PREFIX_MAP } from "../../shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../../shared/prefixes.js";
 import type { BlockDetailed } from "../../shared/types/index.js";
 import type { AspectFlags } from "../types.js";
 import formatters from "./lookup.js";
 
 const BUTTON_DETAILED: BlockDetailed = {
-  uri: `${PREFIX_MAP.ds}global.component.button` as URI,
+  uri: `${DEFAULT_PREFIX_MAP.ds}global.component.button` as URI,
   name: "Button",
   type: "component",
   tier: "global",
@@ -40,7 +40,7 @@ const BUTTON_DETAILED: BlockDetailed = {
   ],
   modifierFamilies: [
     {
-      uri: `${PREFIX_MAP.ds}modifier_family.importance` as URI,
+      uri: `${DEFAULT_PREFIX_MAP.ds}modifier_family.importance` as URI,
       name: "importance",
       values: ["default", "primary", "secondary"],
     },
@@ -56,7 +56,7 @@ const BUTTON_DETAILED: BlockDetailed = {
   ],
   subcomponents: [
     {
-      uri: `${PREFIX_MAP.ds}global.subcomponent.button.icon` as URI,
+      uri: `${DEFAULT_PREFIX_MAP.ds}global.subcomponent.button.icon` as URI,
       name: "Button Icon",
     },
   ],
@@ -65,7 +65,7 @@ const BUTTON_DETAILED: BlockDetailed = {
   ],
   tokens: [
     {
-      uri: `${PREFIX_MAP.ds}token.color.primary` as URI,
+      uri: `${DEFAULT_PREFIX_MAP.ds}token.color.primary` as URI,
       name: "color.primary",
     },
   ],

package/src/domains/block/orchestration/enrichBlocks.ts

@@ -14,12 +14,15 @@ export default async function enrichBlocks(
   filters: FilterConfig,
   disclosure: Disclosure,
 ): Promise<readonly (BlockListDigest | BlockDetailed)[]> {
+  // Look up by each summary's stable unique URI, not its display name: names
+  // recur across tiers/packages, so a by-name lookup returns every same-named
+  // block and taking the first match collapses distinct blocks onto one.
   const nested = await Promise.all(
-    summaries.map((summary) => lookupBlock(store, summary.name, filters)),
+    summaries.map((summary) => lookupBlock(store, summary.uri, filters)),
   );
-  // lookupBlock returns BlockDetailed[] — take the first match per summary
+  // lookupBlock returns BlockDetailed[] — the URI resolves to exactly one match
   const details: BlockDetailed[] = nested.flatMap((matches) =>
-    matches[0] ? [matches[0]] : [],
+    matches.at(0) ? [matches[0] as BlockDetailed] : [],
   );
 
   if (disclosure.level === "detailed") {

package/src/domains/block/stories.ts

@@ -113,9 +113,15 @@ export const blockLookupStory: LookupStory<BlockDetailed, BlockLookupInput> = {
   complete: async (partial, cmdCtx) => {
     const ctx = requirePragmaContext(cmdCtx);
     const all = await listBlocks(ctx.store, ctx.config);
-    return all
-      .map((block) => block.name)
-      .filter((name) => name.toLowerCase().startsWith(partial.toLowerCase()));
+    const lower = partial.toLowerCase();
+    // Block names recur across tiers/packages; dedupe so completion offers each
+    // name once.
+    const unique = new Set(
+      all
+        .map((block) => block.name)
+        .filter((name) => name.toLowerCase().startsWith(lower)),
+    );
+    return [...unique];
   },
   detailedParam: {
     description:

package/src/domains/config/commands/channel.test.ts

@@ -60,6 +60,22 @@ describe("config channel command", () => {
     }
   });
 
+  it("rejects a value combined with --reset", async () => {
+    const ctx = makeCtx(dir);
+    const cmd = buildChannelCommand(ctx);
+    await expect(
+      cmd.execute({ value: "experimental", reset: true }, ctx),
+    ).rejects.toMatchObject({ code: "INVALID_INPUT" });
+  });
+
+  it("rejects an explicit empty-string value", async () => {
+    const ctx = makeCtx(dir);
+    const cmd = buildChannelCommand(ctx);
+    await expect(cmd.execute({ value: "" }, ctx)).rejects.toMatchObject({
+      code: "INVALID_INPUT",
+    });
+  });
+
   it("resets channel via --reset flag", async () => {
     writeFileSync(
       join(dir, "pragma.config.json"),

package/src/domains/config/commands/channel.ts

@@ -5,6 +5,7 @@ import {
 } from "@canonical/cli-core";
 import { runTask } from "@canonical/task/node";
 import { readConfig } from "#config";
+import { PragmaError } from "#error";
 import type { PragmaContext } from "../../shared/context.js";
 import { selectFormatter } from "../../shared/formatters.js";
 import { channelFormatters } from "../formatters/index.js";
@@ -56,6 +57,16 @@ export default function buildChannelCommand(
       const reset = params.reset === true;
       const value = params.value as string | undefined;
 
+      // Contradictory input: a value AND --reset. Reject rather than silently
+      // letting one win.
+      if (reset && value !== undefined) {
+        throw PragmaError.invalidInput("channel", value, {
+          recovery: {
+            message: "Pass either a channel value or --reset, not both.",
+          },
+        });
+      }
+
       if (reset) {
         const result = await runTask(setChannelTask(ctx.cwd, undefined, scope));
         const format = selectFormatter(ctx, channelFormatters.reset);
@@ -65,7 +76,9 @@ export default function buildChannelCommand(
         );
       }
 
-      if (!value) {
+      // No value at all → query the current channel. An explicit empty string
+      // is invalid input, not a query.
+      if (value === undefined) {
         const config = readConfig(ctx.cwd);
         const format = selectFormatter(ctx, channelFormatters.query);
         return createOutputResult(config.channel, {

package/src/domains/config/commands/framework.test.ts

@@ -62,6 +62,20 @@ describe("config framework command", () => {
     expect(readConfig(dir).framework).toBe("lit");
   });
 
+  it("rejects a value combined with --reset", async () => {
+    const ctx = makeCtx(dir);
+    await expect(
+      buildFrameworkCommand(ctx).execute({ value: "react", reset: true }, ctx),
+    ).rejects.toMatchObject({ code: "INVALID_INPUT" });
+  });
+
+  it("rejects an explicit empty-string value", async () => {
+    const ctx = makeCtx(dir);
+    await expect(
+      buildFrameworkCommand(ctx).execute({ value: "" }, ctx),
+    ).rejects.toMatchObject({ code: "INVALID_INPUT" });
+  });
+
   it("rejects an invalid framework", async () => {
     const ctx = makeCtx(dir);
     await expect(

package/src/domains/config/commands/framework.ts

@@ -5,6 +5,7 @@ import {
 } from "@canonical/cli-core";
 import { runTask } from "@canonical/task/node";
 import { readConfig } from "#config";
+import { PragmaError } from "#error";
 import type { PragmaContext } from "../../shared/context.js";
 import { selectFormatter } from "../../shared/formatters.js";
 import { frameworkFormatters } from "../formatters/index.js";
@@ -59,6 +60,16 @@ export default function buildFrameworkCommand(
       const reset = params.reset === true;
       const value = params.value as string | undefined;
 
+      // Contradictory input: a value AND --reset. Reject rather than silently
+      // letting one win.
+      if (reset && value !== undefined) {
+        throw PragmaError.invalidInput("framework", value, {
+          recovery: {
+            message: "Pass either a framework value or --reset, not both.",
+          },
+        });
+      }
+
       if (reset) {
         const result = await runTask(
           setFrameworkTask(ctx.cwd, undefined, scope),
@@ -70,7 +81,8 @@ export default function buildFrameworkCommand(
         );
       }
 
-      if (!value) {
+      // No value at all → query. An explicit empty string is invalid input.
+      if (value === undefined) {
         const config = readConfig(ctx.cwd);
         const format = selectFormatter(ctx, frameworkFormatters.query);
         return createOutputResult(config.framework ?? "none", {

package/src/domains/config/commands/tier.test.ts

@@ -92,4 +92,11 @@ describe("config tier command", () => {
       expect(text).toBe("No tier set (all tiers visible).");
     }
   });
+
+  it("rejects a tier path combined with --reset", async () => {
+    const ctx = makeCtx(dir);
+    await expect(
+      buildTierCommand(ctx).execute({ path: "apps/lxd", reset: true }, ctx),
+    ).rejects.toMatchObject({ code: "INVALID_INPUT" });
+  });
 });

package/src/domains/config/commands/tier.ts

@@ -5,6 +5,7 @@ import {
 } from "@canonical/cli-core";
 import { runTask } from "@canonical/task/node";
 import { readConfig } from "#config";
+import { PragmaError } from "#error";
 import type { PragmaContext } from "../../shared/context.js";
 import { selectFormatter } from "../../shared/formatters.js";
 import { tierFormatters } from "../formatters/index.js";
@@ -53,6 +54,16 @@ export default function buildTierCommand(
       const reset = params.reset === true;
       const tierPath = params.path as string | undefined;
 
+      // Contradictory input: a tier path AND --reset. Reject rather than
+      // silently letting one win.
+      if (reset && tierPath !== undefined) {
+        throw PragmaError.invalidInput("tier", tierPath, {
+          recovery: {
+            message: "Pass either a tier path or --reset, not both.",
+          },
+        });
+      }
+
       if (reset) {
         const result = await runTask(setTierTask(ctx.cwd, undefined, scope));
         const format = selectFormatter(ctx, tierFormatters.reset);
@@ -62,7 +73,9 @@ export default function buildTierCommand(
         );
       }
 
-      if (!tierPath) {
+      // No path at all → query. An explicit empty string is invalid input and
+      // is rejected by validateTier below.
+      if (tierPath === undefined) {
         const config = readConfig(ctx.cwd);
         const format = selectFormatter(ctx, tierFormatters.query);
         return createOutputResult(config.tier, {

package/src/domains/config/operations/validateTier.test.ts

@@ -30,6 +30,15 @@ describe("validateTier", () => {
     expect(entry.path).toBe("global");
   });
 
+  it("matches case- and whitespace-insensitively", async () => {
+    // The documented lowercase slash-path must match regardless of the label's
+    // casing in the ontology (e.g. real graph uses `Apps/LXD`).
+    const upper = await validateTier(store, "APPS/LXD");
+    expect(upper.path).toBe("apps/lxd");
+    const padded = await validateTier(store, "  Apps/Lxd  ");
+    expect(padded.path).toBe("apps/lxd");
+  });
+
   it("throws INVALID_INPUT for a nonexistent tier", async () => {
     await expect(validateTier(store, "apps/nonexistent")).rejects.toThrow(
       'Invalid tier "apps/nonexistent"',

package/src/domains/config/operations/validateTier.ts

@@ -1,7 +1,12 @@
 import type { Store } from "@canonical/ke";
 import { PragmaError } from "#error";
+import { listTiers } from "../../shared/listTiers.js";
 import type { TierEntry } from "../../shared/types/index.js";
-import { listTiers } from "../../tier/operations/index.js";
+
+/** Normalise a tier path for comparison: trim and lowercase. */
+function normalizeTierPath(path: string): string {
+  return path.trim().toLowerCase();
+}
 
 /**
  * Validate a tier path against the ke store ontology.
@@ -17,7 +22,10 @@ export default async function validateTier(
   tierPath: string,
 ): Promise<TierEntry> {
   const tiers = await listTiers(store);
-  const match = tiers.find((t) => t.path === tierPath);
+  // Compare case/format-insensitively so the documented lowercase slash-path
+  // (`apps/lxd`) matches the ontology's title-case label (`Apps/LXD`).
+  const target = normalizeTierPath(tierPath);
+  const match = tiers.find((t) => normalizeTierPath(t.path) === target);
 
   if (!match) {
     const validPaths = tiers.map((t) => t.path);

package/src/domains/create/generatorPack/bundled.ts

@@ -0,0 +1,49 @@
+/**
+ * Bundled generator packs.
+ *
+ * The generator sets pragma ships by default, statically imported so the
+ * single-file build embeds them. Each package's full generator set is exposed —
+ * every generator, always — grouped into `create <noun>` commands and
+ * `create_<noun>` MCP tools by {@link compileGeneratorPack}.
+ *
+ * This is the write-side counterpart of the bundled story packs. In a later
+ * slice these move into the packages themselves (declared, dynamically
+ * resolved) so the core ships no generator wiring at all; today they are
+ * bundled transitional entries, like the story packs.
+ */
+
+import { generators as applicationGenerators } from "@canonical/summon-application";
+import { generators as componentGenerators } from "@canonical/summon-component";
+import { generators as packageGenerators } from "@canonical/summon-package";
+import compileGeneratorPack, {
+  type CompiledGeneratorPack,
+  type GeneratorSet,
+} from "./compileGeneratorPack.js";
+
+/** Every generator set pragma bundles, in surface order. */
+const BUNDLED_GENERATOR_SETS: readonly GeneratorSet[] = [
+  componentGenerators,
+  packageGenerators,
+  applicationGenerators,
+];
+
+let cached: CompiledGeneratorPack | undefined;
+
+/**
+ * Compile every bundled generator pack into its CLI commands and MCP specs.
+ *
+ * Memoized — the generator sets are static, and both the CLI and MCP
+ * registration paths call this.
+ *
+ * @returns The merged commands and specs across all bundled packs.
+ */
+export default function bundledGeneratorPacks(): CompiledGeneratorPack {
+  cached ??= BUNDLED_GENERATOR_SETS.map(compileGeneratorPack).reduce(
+    (merged, pack) => ({
+      commands: [...merged.commands, ...pack.commands],
+      specs: [...merged.specs, ...pack.specs],
+    }),
+    { commands: [], specs: [] },
+  );
+  return cached;
+}

package/src/domains/create/generatorPack/compileGeneratorPack.test.ts

@@ -0,0 +1,159 @@
+import type { AnyGenerator } from "@canonical/summon-core";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { PragmaRuntime } from "../../shared/types/index.js";
+import bundledGeneratorPacks from "./bundled.js";
+import compileGeneratorPack from "./compileGeneratorPack.js";
+
+describe("compileGeneratorPack (bundled)", () => {
+  const { commands, specs } = bundledGeneratorPacks();
+  const cliPaths = commands.map((c) => c.path.join(" "));
+  const toolNames = specs.map((s) => s.name);
+
+  it("exposes every generator from every bundled package as a create command", () => {
+    // component (react/svelte/lit → one noun), package, and the four
+    // application-package generators.
+    expect(cliPaths).toEqual([
+      "create component",
+      "create package",
+      "create application",
+      "create domain",
+      "create route",
+      "create wrapper",
+    ]);
+  });
+
+  it("emits a matching MCP tool per noun", () => {
+    expect(toolNames).toEqual([
+      "create_component",
+      "create_package",
+      "create_application",
+      "create_domain",
+      "create_route",
+      "create_wrapper",
+    ]);
+  });
+
+  it("dispatches a multi-variant noun via a `variant` positional select", () => {
+    const component = commands.find(
+      (c) => c.path.join(" ") === "create component",
+    );
+    const variant = component?.parameters.find((p) => p.name === "variant");
+    expect(variant?.type).toBe("select");
+    expect(variant?.positional).toBe(true);
+    expect(variant?.choices?.map((ch) => ch.value)).toEqual([
+      "react",
+      "svelte",
+      "lit",
+    ]);
+  });
+
+  it("gives the multi-variant MCP tool a `variant` enum parameter", () => {
+    const component = specs.find((s) => s.name === "create_component");
+    expect(component?.params?.variant?.enum).toEqual([
+      "react",
+      "svelte",
+      "lit",
+    ]);
+  });
+
+  it("collapses a single-variant noun to a plain `create <noun>` (no variant arg)", () => {
+    const application = commands.find(
+      (c) => c.path.join(" ") === "create application",
+    );
+    expect(application?.parameters.some((p) => p.name === "variant")).toBe(
+      false,
+    );
+    // Its prompts still project — appPath comes from the generator.
+    expect(application?.parameters.some((p) => p.name === "appPath")).toBe(
+      true,
+    );
+  });
+
+  it("derives single-generator MCP params from the generator's prompts", () => {
+    const pkg = specs.find((s) => s.name === "create_package");
+    expect(pkg?.params).toBeDefined();
+    // The package generator prompts for a package name.
+    expect(Object.keys(pkg?.params ?? {}).length).toBeGreaterThan(0);
+  });
+
+  it("never advertises params the runner pins (runInstall is forced off)", () => {
+    // The runner always executes a dry-run plan with runInstall: false, so
+    // no create tool may advertise the parameter it would ignore.
+    for (const spec of specs) {
+      expect(spec.params).not.toHaveProperty("runInstall");
+    }
+  });
+});
+
+/** Minimal synthetic generator for edge-case tests. */
+function makeGenerator(name: string, generate?: () => never): AnyGenerator {
+  return {
+    meta: {
+      name,
+      displayName: name,
+      description: `Test generator ${name}`,
+      version: "0.0.0",
+    },
+    prompts: [],
+    generate:
+      generate ??
+      (() => {
+        throw new Error("not exercised");
+      }),
+  } as unknown as AnyGenerator;
+}
+
+describe("compileGeneratorPack — edge cases", () => {
+  let warnings: string[];
+  let warn: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    warnings = [];
+    warn = vi
+      .spyOn(process.stderr, "write")
+      .mockImplementation((chunk: string | Uint8Array) => {
+        warnings.push(String(chunk));
+        return true;
+      });
+  });
+
+  afterEach(() => {
+    warn.mockRestore();
+  });
+
+  it("warns and exposes only the first generator of a mixed bare/variant noun", () => {
+    const { commands, specs } = compileGeneratorPack({
+      thing: makeGenerator("thing"),
+      "thing/extra": makeGenerator("thing/extra"),
+    });
+    expect(commands.map((c) => c.path.join(" "))).toEqual(["create thing"]);
+    expect(specs.map((s) => s.name)).toEqual(["create_thing"]);
+    expect(warnings.join("")).toContain("mixes bare and variant keys");
+  });
+
+  it("maps a generator that throws to INVALID_INPUT with its message as recovery", async () => {
+    const throwing = makeGenerator("boom", () => {
+      throw new Error("boom requires --both flags");
+    });
+    const { specs } = compileGeneratorPack({ boom: throwing });
+    const spec = specs.at(0);
+    const rt = { cwd: "/tmp" } as PragmaRuntime;
+    await expect(spec?.execute(rt, {})).rejects.toMatchObject({
+      code: "INVALID_INPUT",
+      recovery: { message: "boom requires --both flags" },
+    });
+  });
+
+  it("rejects an unknown variant with INVALID_INPUT and the valid options", async () => {
+    const { specs } = compileGeneratorPack({
+      "widget/a": makeGenerator("widget/a"),
+      "widget/b": makeGenerator("widget/b"),
+    });
+    const spec = specs.at(0);
+    const rt = { cwd: "/tmp" } as PragmaRuntime;
+    await expect(spec?.execute(rt, { variant: "c" })).rejects.toMatchObject({
+      code: "INVALID_INPUT",
+      validOptions: ["a", "b"],
+    });
+  });
+});