@canonical/pragma-cli 0.31.0 → 0.32.0

package/src/config/resolveWriteConfigPath.test.ts

@@ -1,53 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import resolveWriteConfigPath from "./resolveWriteConfigPath.js";
-
-describe("resolveWriteConfigPath", () => {
-  let xdgDir: string;
-  let projectDir: string;
-  let originalXdg: string | undefined;
-
-  beforeEach(() => {
-    originalXdg = process.env.XDG_CONFIG_HOME;
-    xdgDir = mkdtempSync(join(tmpdir(), "pragma-write-xdg-"));
-    process.env.XDG_CONFIG_HOME = xdgDir;
-    projectDir = mkdtempSync(join(tmpdir(), "pragma-write-project-"));
-    mkdirSync(join(projectDir, ".git"));
-  });
-
-  afterEach(() => {
-    process.env.XDG_CONFIG_HOME = originalXdg;
-    rmSync(xdgDir, { recursive: true, force: true });
-    rmSync(projectDir, { recursive: true, force: true });
-  });
-
-  it("targets the nearest existing project file", () => {
-    writeFileSync(join(projectDir, "pragma.config.json"), "{}");
-    const sub = join(projectDir, "packages/app");
-    mkdirSync(sub, { recursive: true });
-    expect(resolveWriteConfigPath(sub)).toBe(
-      join(projectDir, "pragma.config.json"),
-    );
-  });
-
-  it("falls back to the global file when no project file exists", () => {
-    expect(resolveWriteConfigPath(projectDir)).toBe(
-      join(xdgDir, "pragma/config.json"),
-    );
-  });
-
-  it("honors an explicit local scope even without an existing file", () => {
-    expect(resolveWriteConfigPath(projectDir, "local")).toBe(
-      join(projectDir, "pragma.config.json"),
-    );
-  });
-
-  it("honors an explicit global scope over an existing project file", () => {
-    writeFileSync(join(projectDir, "pragma.config.json"), "{}");
-    expect(resolveWriteConfigPath(projectDir, "global")).toBe(
-      join(xdgDir, "pragma/config.json"),
-    );
-  });
-});

package/src/config/resolveWriteConfigPath.ts

@@ -1,31 +0,0 @@
-import findProjectConfigPath from "./findProjectConfigPath.js";
-import resolveConfigPath from "./resolveConfigPath.js";
-import resolveGlobalConfigPath from "./resolveGlobalConfigPath.js";
-import type { ConfigScope } from "./types.js";
-
-/**
- * Resolve which config file a write should target.
- *
- * An explicit scope wins: `"local"` targets `<cwd>/pragma.config.json`,
- * `"global"` targets the XDG file. Otherwise the nearest existing project
- * file up the tree is updated in place, and when none exists the write
- * goes to the global file — pragma is global-first: an unconfigured
- * directory should not sprout a project file as a side effect.
- *
- * @param cwd - Directory the project layer is resolved from.
- * @param scope - Optional explicit target layer.
- * @returns Absolute path of the config file to write.
- * @note Impure — probes the filesystem for the nearest project file.
- */
-export default function resolveWriteConfigPath(
-  cwd: string,
-  scope?: ConfigScope,
-): string {
-  if (scope === "local") {
-    return resolveConfigPath(cwd);
-  }
-  if (scope === "global") {
-    return resolveGlobalConfigPath();
-  }
-  return findProjectConfigPath(cwd) ?? resolveGlobalConfigPath();
-}

package/src/config/types.ts

@@ -1,128 +0,0 @@
-/**
- * Configuration data shapes for pragma.config.json.
- *
- * Separates the persisted config shape from the read/write logic
- * so consumers can import types without pulling in filesystem code.
- */
-
-import type { Channel, Framework } from "../constants.js";
-import type { RawPackageEntry } from "../domains/refs/operations/parseRef.js";
-import type { StoryPackDefinition } from "../domains/shared/stories/pack/types.js";
-
-/** Parsed contents of pragma.config.json. */
-interface PragmaConfig {
-  /** Active tier path, or `undefined` when no tier is configured. */
-  tier: string | undefined;
-  /** Release channel controlling component visibility. */
-  channel: Channel;
-  /**
-   * Semantic package sources. Each entry is a package name (npm) or an
-   * object with `{ name, source }` where source is `file://` or `git+https://`.
-   * When absent, the hardcoded defaults are used.
-   */
-  packages?: ReadonlyArray<RawPackageEntry> | undefined;
-  /** Whether query access tracing is enabled. Overridden by PRAGMA_TRACE env var. */
-  trace?: boolean | undefined;
-  /**
-   * Preferred UI framework (`react` | `svelte` | `lit`). Currently advisory
-   * only — no behaviour reads it yet; reserved for future framework defaulting.
-   */
-  framework?: Framework | undefined;
-  /**
-   * Declarative read stories compiled into CLI commands and MCP tools at
-   * boot.
-   * @experimental Story packs (v0) are experimental — the format may change.
-   */
-  stories?: ReadonlyArray<StoryPackDefinition> | undefined;
-  /**
-   * Additional namespace prefixes merged over the built-in prefix map —
-   * registered on the store (usable in queries) and used for display.
-   */
-  prefixes?: Readonly<Record<string, string>> | undefined;
-  /**
-   * Default progressive-disclosure level for disclosure-capable commands
-   * (e.g. `"digest"`, `"detailed"`). An explicit `--detail` flag overrides it.
-   */
-  detail?: string | undefined;
-}
-
-/** Partial update payload for writing config changes. */
-interface ConfigUpdate {
-  /** New tier path, `undefined` to remove the tier field. */
-  tier?: string | undefined;
-  /** New channel, `undefined` to remove the channel field. */
-  channel?: Channel | undefined;
-  /** New packages list, `undefined` to remove the field. */
-  packages?: ReadonlyArray<RawPackageEntry> | undefined;
-  /** Enable/disable query tracing, `undefined` to remove the field. */
-  trace?: boolean | undefined;
-  /** New preferred framework, `undefined` to remove the field. */
-  framework?: Framework | undefined;
-}
-
-/**
- * Values a single config file declares. A key is present only when the
- * file sets it — presence drives which layer wins during merging.
- */
-interface ConfigFileValues {
-  readonly tier?: string;
-  readonly channel?: Channel;
-  readonly packages?: ReadonlyArray<RawPackageEntry>;
-  readonly trace?: boolean;
-  readonly framework?: Framework;
-  readonly stories?: ReadonlyArray<StoryPackDefinition>;
-  readonly prefixes?: Readonly<Record<string, string>>;
-  readonly detail?: string;
-}
-
-/** Which config layer supplied an effective field value. */
-type ConfigOrigin = "default" | "global" | "project";
-
-/** Per-field provenance for the effective merged config. */
-interface ConfigOrigins {
-  readonly tier: ConfigOrigin;
-  readonly channel: ConfigOrigin;
-  readonly packages: ConfigOrigin;
-  readonly trace: ConfigOrigin;
-  readonly framework: ConfigOrigin;
-  readonly stories: ConfigOrigin;
-  readonly prefixes: ConfigOrigin;
-  readonly detail: ConfigOrigin;
-}
-
-/** A resolved config file layer. */
-interface ConfigLayer {
-  /** Absolute path of the layer's config file (existing or would-be). */
-  readonly path: string;
-  /** Whether the file exists and was readable. */
-  readonly exists: boolean;
-}
-
-/** Layered config resolution result with per-field provenance. */
-interface ConfigLayers {
-  /** The effective merged configuration (defaults < global < project). */
-  readonly config: PragmaConfig;
-  /** Which layer supplied each effective field. */
-  readonly origins: ConfigOrigins;
-  /** The global XDG layer (`$XDG_CONFIG_HOME/pragma/config.json`). */
-  readonly global: ConfigLayer;
-  /**
-   * The project layer: the nearest `pragma.config.json` up the tree, or
-   * the would-be path at `cwd` when none exists.
-   */
-  readonly project: ConfigLayer;
-}
-
-/** Target layer selector for config writes. */
-type ConfigScope = "global" | "local";
-
-export type {
-  ConfigFileValues,
-  ConfigLayer,
-  ConfigLayers,
-  ConfigOrigin,
-  ConfigOrigins,
-  ConfigScope,
-  ConfigUpdate,
-  PragmaConfig,
-};

package/src/config/writeConfig.ts

@@ -1,37 +0,0 @@
-import { mkdirSync, renameSync, writeFileSync } from "node:fs";
-import { dirname } from "node:path";
-import mergeConfigFileUpdate from "./mergeConfigFileUpdate.js";
-import resolveWriteConfigPath from "./resolveWriteConfigPath.js";
-import type { ConfigScope, ConfigUpdate } from "./types.js";
-
-/**
- * Write config updates to the resolved target layer.
- *
- * The target follows the global-first write rule (see
- * `resolveWriteConfigPath`): an explicit scope wins, else the nearest
- * existing project file, else the global XDG file. Merges updates into
- * that file's own contents — a field set to `undefined` removes it —
- * creating the file (and its directory) if needed, atomically via a
- * temp file rename.
- *
- * @param cwd - Directory the project layer is resolved from.
- * @param update - Fields to set or remove.
- * @param scope - Optional explicit target layer (`"global"` | `"local"`).
- * @returns Absolute path of the file that was written.
- *
- * @note Impure — writes to the filesystem.
- */
-export default function writeConfig(
-  cwd: string,
-  update: ConfigUpdate,
-  scope?: ConfigScope,
-): string {
-  const configPath = resolveWriteConfigPath(cwd, scope);
-  const tempPath = `${configPath}.tmp`;
-  const content = mergeConfigFileUpdate(configPath, update);
-
-  mkdirSync(dirname(configPath), { recursive: true });
-  writeFileSync(tempPath, content);
-  renameSync(tempPath, configPath);
-  return configPath;
-}

package/src/domains/block/blockConfig.ts

@@ -1,97 +0,0 @@
-import type { EntityDisplayConfig } from "../shared/contracts.js";
-import { P } from "../shared/prefixes.js";
-import type {
-  BlockDetailed,
-  BlockDigest,
-  BlockSummary,
-  FilterConfig,
-} from "../shared/types/index.js";
-
-/** Display-contract configuration for block entities (components, patterns, layouts). */
-export const blockConfig: EntityDisplayConfig<
-  BlockSummary,
-  BlockDigest,
-  BlockDetailed
-> = {
-  domain: "block",
-  entityName: "block",
-  rdfTypes: [
-    `${P.ds}Component`,
-    `${P.ds}Pattern`,
-    `${P.ds}Layout`,
-    `${P.ds}Subcomponent`,
-  ],
-  listColumns: [
-    { key: "uri", label: "IRI" },
-    { key: "name", label: "Name" },
-    { key: "type", label: "Type" },
-    { key: "tier", label: "Tier" },
-    {
-      key: "modifiers",
-      label: "Modifiers",
-      showWhenEmpty: false,
-      format: (value) =>
-        Array.isArray(value)
-          ? value.filter((entry) => typeof entry === "string").join(", ")
-          : "",
-    },
-    {
-      key: "implementations",
-      label: "Implementations",
-      showWhenEmpty: false,
-      format: (value) =>
-        Array.isArray(value)
-          ? value
-              .filter(
-                (entry): entry is { framework: string; available: boolean } =>
-                  typeof entry === "object" &&
-                  entry !== null &&
-                  "framework" in entry &&
-                  "available" in entry,
-              )
-              .filter((entry) => entry.available)
-              .map((entry) => entry.framework)
-              .join(", ")
-          : "",
-    },
-    {
-      key: "nodeCount",
-      label: "Nodes",
-      showWhenEmpty: false,
-      format: (value) =>
-        typeof value === "number" && value > 0 ? String(value) : "",
-    },
-    {
-      key: "tokenCount",
-      label: "Tokens",
-      showWhenEmpty: false,
-      format: (value) =>
-        typeof value === "number" && value > 0 ? String(value) : "",
-    },
-  ],
-  digestColumns: [{ key: "summary", label: "Summary", showWhenEmpty: false }],
-  lookupSections: [
-    { key: "summary", heading: "Summary", kind: "field" },
-    { key: "whenToUse", heading: "When to use", kind: "field" },
-    { key: "whenNotToUse", heading: "When not to use", kind: "field" },
-    { key: "guidelines", heading: "Guidelines", kind: "field" },
-    { key: "anatomy", heading: "Anatomy", kind: "tree" },
-    { key: "anatomyDsl", heading: "Anatomy (DSL)", kind: "code" },
-    { key: "anatomyClassic", heading: "Anatomy (classic)", kind: "field" },
-    { key: "modifierFamilies", heading: "Modifiers", kind: "table" },
-    { key: "properties", heading: "Properties", kind: "nested-table" },
-    { key: "subcomponents", heading: "Subcomponents", kind: "tree" },
-    { key: "implementationPaths", heading: "Implementations", kind: "list" },
-    { key: "tokens", heading: "Tokens", kind: "list" },
-  ],
-  emptyRecovery: (_filters: FilterConfig) => ({
-    message: "List visible blocks.",
-    cli: "pragma block list",
-    mcp: { tool: "block_list" },
-  }),
-  notFoundRecovery: (_query: string) => ({
-    message: "List visible blocks.",
-    cli: "pragma block list",
-    mcp: { tool: "block_list" },
-  }),
-};

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

@@ -1,5 +0,0 @@
-/** @module Re-exports block command builders (`list`, `lookup`, `sample`). */
-
-export { default as listCommand } from "./list.js";
-export { default as lookupCommand } from "./lookup.js";
-export { default as sampleCommand } from "./sample.js";

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

@@ -1,111 +0,0 @@
-import type { CommandDefinition } from "@canonical/cli-core";
-import type { Store } from "@canonical/ke";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { createTestStore, DS_ALL_TTL } from "#testing";
-import type { PragmaContext } from "../../shared/context.js";
-import type { BlockSummary } from "../../shared/types/index.js";
-import buildListCommand from "./list.js";
-
-let store: Store;
-let cleanup: () => void;
-
-beforeAll(async () => {
-  const result = await createTestStore({ ttl: DS_ALL_TTL });
-  store = result.store;
-  cleanup = result.cleanup;
-});
-
-afterAll(() => cleanup());
-
-function makeCtx(overrides: Partial<PragmaContext> = {}): PragmaContext {
-  return {
-    cwd: "/tmp",
-    globalFlags: { llm: false, format: "text" as const, verbose: false },
-    store,
-    config: { tier: undefined, channel: "prerelease" },
-    ...overrides,
-  };
-}
-
-async function executeOutput(
-  cmd: CommandDefinition,
-  params: Record<string, unknown>,
-  ctx: PragmaContext,
-): Promise<{ value: unknown; text: string }> {
-  const result = await cmd.execute(params, ctx);
-  expect(result.tag).toBe("output");
-  if (result.tag !== "output") throw new Error("Expected output result");
-  const text = result.render.plain(result.value);
-  return { value: result.value, text };
-}
-
-describe("buildListCommand", () => {
-  it("returns output result with block data", async () => {
-    const ctx = makeCtx();
-    const cmd = buildListCommand(ctx);
-    const { value } = await executeOutput(cmd, {}, ctx);
-    const names = (value as BlockSummary[]).map((c) => c.name);
-    expect(names).toContain("Button");
-    expect(names).toContain("Card");
-  });
-
-  it("renders plain text output", async () => {
-    const ctx = makeCtx();
-    const cmd = buildListCommand(ctx);
-    const { text } = await executeOutput(cmd, {}, ctx);
-    expect(text).toContain("Button");
-    expect(text).toContain("Card");
-  });
-
-  it("renders LLM markdown", async () => {
-    const ctx = makeCtx({
-      globalFlags: { llm: true, format: "text" as const, verbose: false },
-    });
-    const cmd = buildListCommand(ctx);
-    const { text } = await executeOutput(cmd, {}, ctx);
-    expect(text).toContain("## Blocks");
-    expect(text).toContain("**Button**");
-  });
-
-  it("renders JSON output", async () => {
-    const ctx = makeCtx({
-      globalFlags: { llm: false, format: "json" as const, verbose: false },
-    });
-    const cmd = buildListCommand(ctx);
-    const { text } = await executeOutput(cmd, {}, ctx);
-    const parsed = JSON.parse(text);
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed.some((c: BlockSummary) => c.name === "Button")).toBe(true);
-  });
-
-  it("respects tier filter from config", async () => {
-    const ctx = makeCtx({
-      config: { tier: "global", channel: "normal" },
-    });
-    const cmd = buildListCommand(ctx);
-    const { value } = await executeOutput(cmd, {}, ctx);
-    const names = (value as BlockSummary[]).map((c) => c.name);
-    expect(names).toContain("Button");
-    expect(names).not.toContain("LXD Panel");
-  });
-
-  it("--all-tiers ignores tier filter", async () => {
-    const ctx = makeCtx({
-      config: { tier: "global", channel: "prerelease" },
-    });
-    const cmd = buildListCommand(ctx);
-    const { value } = await executeOutput(cmd, { allTiers: true }, ctx);
-    const names = (value as BlockSummary[]).map((c) => c.name);
-    expect(names).toContain("Button");
-    expect(names).toContain("LXD Panel");
-  });
-
-  it("returns results with combined tier + channel", async () => {
-    const ctx = makeCtx({
-      config: { tier: "apps/lxd", channel: "normal" },
-    });
-    const cmd = buildListCommand(ctx);
-    const result = await cmd.execute({}, ctx);
-    expect(result.tag).toBe("output");
-  });
-});

package/src/domains/block/commands/list.ts

@@ -1,11 +0,0 @@
-import type { CommandDefinition } from "@canonical/cli-core";
-import type { PragmaContext } from "../../shared/context.js";
-import { compileReadCommand } from "../../shared/stories/index.js";
-import { blockListStory } from "../stories.js";
-
-/** Wire the `pragma block list` CLI command from the block list story. */
-export default function buildListCommand(
-  ctx: PragmaContext,
-): CommandDefinition {
-  return compileReadCommand(ctx, blockListStory);
-}

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

@@ -1,187 +0,0 @@
-import type { CommandDefinition } from "@canonical/cli-core";
-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 type { PragmaContext } from "../../shared/context.js";
-import buildLookupCommand from "./lookup.js";
-
-let store: Store;
-let cleanup: () => void;
-
-beforeAll(async () => {
-  const result = await createTestStore({ ttl: DS_ALL_TTL });
-  store = result.store;
-  cleanup = result.cleanup;
-});
-
-afterAll(() => cleanup());
-
-function makeCtx(overrides: Partial<PragmaContext> = {}): PragmaContext {
-  return {
-    cwd: "/tmp",
-    globalFlags: { llm: false, format: "text" as const, verbose: false },
-    store,
-    config: { tier: undefined, channel: "prerelease" },
-    ...overrides,
-  };
-}
-
-async function executeOutput(
-  cmd: CommandDefinition,
-  params: Record<string, unknown>,
-  ctx: PragmaContext,
-): Promise<{ value: unknown; text: string }> {
-  const result = await cmd.execute(params, ctx);
-  expect(result.tag).toBe("output");
-  if (result.tag !== "output") throw new Error("Expected output result");
-  const text = result.render.plain(result.value);
-  return { value: result.value, text };
-}
-
-describe("buildLookupCommand", () => {
-  it("returns summary by default", async () => {
-    const ctx = makeCtx();
-    const cmd = buildLookupCommand(ctx);
-    const { text } = await executeOutput(cmd, { names: ["Button"] }, ctx);
-    expect(text).toContain("Button");
-    expect(text).toContain("global");
-  });
-
-  it("returns detailed view with --detailed", async () => {
-    const ctx = makeCtx();
-    const cmd = buildLookupCommand(ctx);
-    const { text } = await executeOutput(
-      cmd,
-      { names: ["Button"], detailed: true },
-      ctx,
-    );
-    expect(text).toContain("Button");
-    expect(text).toContain("Modifiers");
-    expect(text).toContain("importance");
-  });
-
-  it("shows only selected aspects (--modifiers)", async () => {
-    const ctx = makeCtx();
-    const cmd = buildLookupCommand(ctx);
-    const { text } = await executeOutput(
-      cmd,
-      { names: ["Button"], modifiers: true },
-      ctx,
-    );
-    expect(text).toContain("Modifiers");
-    expect(text).toContain("importance");
-    // Summary field "Tokens: 1" is always shown, but token details should not appear
-    expect(text).not.toContain("color.primary");
-  });
-
-  it("composes aspect flags (--modifiers --tokens)", async () => {
-    const ctx = makeCtx();
-    const cmd = buildLookupCommand(ctx);
-    const { text } = await executeOutput(
-      cmd,
-      { names: ["Button"], modifiers: true, tokens: true },
-      ctx,
-    );
-    expect(text).toContain("Modifiers");
-    expect(text).toContain("Tokens");
-  });
-
-  it("renders LLM markdown", async () => {
-    const ctx = makeCtx({
-      globalFlags: { llm: true, format: "text" as const, verbose: false },
-    });
-    const cmd = buildLookupCommand(ctx);
-    const { text } = await executeOutput(cmd, { names: ["Button"] }, ctx);
-    expect(text).toContain("## Button");
-    expect(text).toContain("Tier: global");
-  });
-
-  it("renders JSON", async () => {
-    const ctx = makeCtx({
-      globalFlags: { llm: false, format: "json" as const, verbose: false },
-    });
-    const cmd = buildLookupCommand(ctx);
-    const { text } = await executeOutput(cmd, { names: ["Button"] }, ctx);
-    const parsed = JSON.parse(text);
-    expect(parsed.name).toBe("Button");
-    expect(parsed.tier).toBe("global");
-  });
-
-  it("renders JSON with detailed aspects", async () => {
-    const ctx = makeCtx({
-      globalFlags: { llm: false, format: "json" as const, verbose: false },
-    });
-    const cmd = buildLookupCommand(ctx);
-    const { text } = await executeOutput(
-      cmd,
-      { names: ["Button"], detailed: true },
-      ctx,
-    );
-    const parsed = JSON.parse(text);
-    expect(parsed.modifierValues).toBeDefined();
-    expect(parsed.tokens).toBeDefined();
-  });
-
-  it("populates nodeCount from anatomy nodes", async () => {
-    const ctx = makeCtx({
-      globalFlags: { llm: false, format: "json" as const, verbose: false },
-    });
-    const cmd = buildLookupCommand(ctx);
-    const { text } = await executeOutput(cmd, { names: ["Button"] }, ctx);
-    const parsed = JSON.parse(text);
-    expect(parsed.nodeCount).toBe(3);
-  });
-
-  it("renders multiple lookup results together", async () => {
-    const ctx = makeCtx();
-    const cmd = buildLookupCommand(ctx);
-    const { text } = await executeOutput(
-      cmd,
-      { names: ["Button", "Card"] },
-      ctx,
-    );
-    expect(text).toContain("Button");
-    expect(text).toContain("Card");
-  });
-
-  it("throws ENTITY_NOT_FOUND for unknown block", async () => {
-    const ctx = makeCtx();
-    const cmd = buildLookupCommand(ctx);
-    const result = await cmd.execute({ names: ["NonExistent"] }, ctx);
-    expect(result.tag).toBe("output");
-
-    if (result.tag !== "output") {
-      expect.fail("Expected output result");
-    }
-
-    const text = result.render.plain(result.value);
-    expect(text).toContain("Errors:");
-    expect(text).toContain("NonExistent");
-  });
-
-  it("throws INVALID_INPUT for empty name", async () => {
-    const ctx = makeCtx();
-    const cmd = buildLookupCommand(ctx);
-    await expect(cmd.execute({ names: [] }, ctx)).rejects.toThrow(PragmaError);
-
-    try {
-      await cmd.execute({ names: [] }, ctx);
-    } catch (e) {
-      expect(e).toBeInstanceOf(PragmaError);
-      expect((e as PragmaError).code).toBe("INVALID_INPUT");
-    }
-  });
-
-  it("provides tab completion candidates", async () => {
-    const ctx = makeCtx();
-    const cmd = buildLookupCommand(ctx);
-    const nameParam = cmd.parameters.find((p) => p.name === "names");
-    expect(nameParam?.complete).toBeDefined();
-
-    if (nameParam?.complete) {
-      const candidates = await nameParam.complete("Bu", ctx);
-      expect(candidates).toContain("Button");
-    }
-  });
-});

package/src/domains/block/commands/lookup.ts

@@ -1,14 +0,0 @@
-import type { CommandDefinition } from "@canonical/cli-core";
-import type { PragmaContext } from "../../shared/context.js";
-import { compileLookupCommand } from "../../shared/stories/index.js";
-import { blockLookupStory } from "../stories.js";
-
-/**
- * Wire the `pragma block lookup <name-or-uri...>` CLI command from the
- * block lookup story.
- */
-export default function buildLookupCommand(
-  ctx: PragmaContext,
-): CommandDefinition {
-  return compileLookupCommand(ctx, blockLookupStory);
-}