@canonical/pragma-cli 0.30.0 → 0.31.0

package/src/testing/integration/parity.test.ts

@@ -42,20 +42,10 @@ import {
 } from "../../domains/ontology/operations/index.js";
 import { CHANNEL_RELEASES } from "../../domains/shared/filters/buildChannelFilter.js";
 import { resolveTierChain } from "../../domains/shared/filters/buildTierFilter.js";
+import { listTiers } from "../../domains/shared/listTiers.js";
 import type { PragmaRuntime } from "../../domains/shared/runtime.js";
-import {
-  type StandardListOutput,
-  categoriesFormatters as standardCatFmt,
-  listFormatters as standardListFmt,
-  lookupFormatters as standardLookupFmt,
-} from "../../domains/standard/formatters/index.js";
-import {
-  listCategories,
-  listStandards,
-  lookupStandard,
-} from "../../domains/standard/operations/index.js";
-import { listFormatters as tierListFmt } from "../../domains/tier/formatters/index.js";
-import { listTiers } from "../../domains/tier/operations/index.js";
+import { listDomainNames } from "../../domains/shared/suggestions/index.js";
+import { TOKEN_READ_SURFACE_ENABLED } from "../../domains/token/featureFlag.js";
 import {
   createLookupFormatters as createTokenLookupFmt,
   listFormatters as tokenListFmt,
@@ -176,58 +166,83 @@ describe("block parity", () => {
 // Standard parity
 // ---------------------------------------------------------------------------
 
-describe("standard parity", () => {
-  it("standard_list: count and names match", async () => {
-    const opResult = await listStandards(rt.store);
+// `standard *` is now served by the bundled `standard` story pack (the
+// hand-written domain was deleted). Pack rows/entities are uniform
+// `Record<string,string>` projections with expand arrays, and rendering is
+// the generic pack renderer — so these tests assert *semantic* parity
+// against the store (every standard reachable, by the same names, with the
+// same category/description/dos/donts values) rather than byte equality
+// with the removed bespoke formatters. See PARITY_GAPS in #testing for the
+// pinned, accepted divergences.
+describe("standard parity (bundled pack)", () => {
+  it("standard_list returns one {uri, name, category, description} row per standard", async () => {
+    const allNames = await listDomainNames(rt.store, "standard");
+    expect(allNames.length).toBeGreaterThan(0);
+
     const mcpRes = await client.callTool({
       name: "standard_list",
       arguments: {},
     });
-    assertParity(opResult, mcpRes);
+    const body = parseEnvelope(mcpRes);
+    expect(body.ok).toBe(true);
+    const rows = body.data as {
+      uri?: string;
+      name?: string;
+      category?: string;
+      description?: string;
+    }[];
+
+    // Same standards, same names — nothing dropped or invented.
+    const listed = new Set(rows.map((row) => row.name));
+    for (const name of allNames) {
+      expect(listed.has(name), `"${name}" missing from standard_list`).toBe(
+        true,
+      );
+    }
+    for (const row of rows) {
+      expect(row.uri).toBeTruthy();
+      expect(row.description).toBeTruthy();
+    }
   });
 
-  it("standard_list condensed: matches llm formatter", async () => {
-    const opResult = await listStandards(rt.store);
-    const output: StandardListOutput = {
-      items: opResult,
-      details: undefined,
-      disclosure: { level: "summary" },
-    };
-    const expectedText = standardListFmt.llm(output);
-
+  it("standard_list condensed lists every standard under the pack heading", async () => {
+    const allNames = await listDomainNames(rt.store, "standard");
     const mcpRes = await client.callTool({
       name: "standard_list",
       arguments: { condensed: true },
     });
     const body = parseCondensed(mcpRes);
-    expect(body.text).toBe(expectedText);
+    expect(body.text).toContain("## Standard");
+    for (const name of allNames) {
+      expect(body.text).toContain(name);
+    }
   });
 
-  it("standard_lookup: detailed fields match", async () => {
-    const opResult = await lookupStandard(
-      rt.store,
-      "react/component/folder-structure",
-    );
+  it("standard_lookup returns full detail by default (MCP full-data contract)", async () => {
     const mcpRes = await client.callTool({
       name: "standard_lookup",
       arguments: { names: ["react/component/folder-structure"] },
     });
     const body = parseEnvelope(mcpRes);
-    const data = body.data as { results: unknown[]; errors: unknown[] };
-    expect(data.results[0]).toEqual(opResult);
+    const data = body.data as {
+      results: {
+        name: string;
+        category: string;
+        dos: { code?: string; language?: string }[];
+        donts: { code?: string }[];
+      }[];
+      errors: unknown[];
+    };
     expect(data.errors).toEqual([]);
+    const entity = data.results[0];
+    expect(entity?.name).toBe("react/component/folder-structure");
+    expect(entity?.category).toBe("react");
+    expect(entity?.dos.length).toBeGreaterThan(0);
+    expect(entity?.dos.every((example) => example.code)).toBe(true);
+    expect(entity?.donts.length).toBeGreaterThan(0);
   });
 
-  it("standard_lookup condensed: matches llm formatter", async () => {
-    const opResult = await lookupStandard(
-      rt.store,
-      "react/component/folder-structure",
-    );
-    const expectedText = standardLookupFmt.llm({
-      standard: opResult,
-      detailed: true,
-    });
-
+  it("standard_lookup condensed renders the entity with its code examples", async () => {
     const mcpRes = await client.callTool({
       name: "standard_lookup",
       arguments: {
@@ -236,28 +251,37 @@ describe("standard parity", () => {
       },
     });
     const body = parseCondensed(mcpRes);
-    expect(body.text).toBe(expectedText);
+    expect(body.text).toContain("## react/component/folder-structure");
+    expect(body.text).toContain("Do");
+    expect(body.text).toContain("src/lib/Button/Button.tsx");
   });
 
-  it("standard_categories: data matches", async () => {
-    const opResult = await listCategories(rt.store);
-    const mcpRes = await client.callTool({
-      name: "standard_categories",
+  it("standard_categories counts agree with the standard list", async () => {
+    const listRes = await client.callTool({
+      name: "standard_list",
       arguments: {},
     });
-    assertParity(opResult, mcpRes);
-  });
-
-  it("standard_categories condensed: matches llm formatter", async () => {
-    const opResult = await listCategories(rt.store);
-    const expectedText = standardCatFmt.llm(opResult);
+    const rows = parseEnvelope(listRes).data as { category?: string }[];
+    const expected = new Map<string, number>();
+    for (const row of rows) {
+      if (row.category) {
+        expected.set(row.category, (expected.get(row.category) ?? 0) + 1);
+      }
+    }
 
     const mcpRes = await client.callTool({
       name: "standard_categories",
-      arguments: { condensed: true },
+      arguments: {},
     });
-    const body = parseCondensed(mcpRes);
-    expect(body.text).toBe(expectedText);
+    const body = parseEnvelope(mcpRes);
+    expect(body.ok).toBe(true);
+    const categories = body.data as { name: string; count: string }[];
+    expect(categories.length).toBeGreaterThan(0);
+    for (const [category, count] of expected) {
+      const row = categories.find((entry) => entry.name === category);
+      expect(row, `category "${category}" missing`).toBeDefined();
+      expect(Number(row?.count)).toBe(count);
+    }
   });
 });
 
@@ -265,26 +289,51 @@ describe("standard parity", () => {
 // Tier parity
 // ---------------------------------------------------------------------------
 
-describe("tier parity", () => {
-  it("tier_list: paths and depths match", async () => {
+// `tier list` / `tier_list` is now served by the bundled `tier` story pack
+// (the hand-written domain was deleted). Pack rows are `Record<string,string>`
+// projected from the SELECT, so the shape is intentionally uniform: `{uri,
+// name}` with no always-zero `depth` field, and the llm renderer is the
+// generic pack renderer. These tests assert *semantic* parity — every tier the
+// shared operation sees is present, by the same names — rather than byte
+// equality with the removed bespoke formatter.
+describe("tier parity (bundled pack)", () => {
+  it("tier_list returns one {uri, name} row per ontology tier", async () => {
     const opResult = await listTiers(rt.store);
-    const mcpRes = await client.callTool({
-      name: "tier_list",
-      arguments: {},
-    });
-    assertParity(opResult, mcpRes);
+    const mcpRes = await client.callTool({ name: "tier_list", arguments: {} });
+
+    const content = mcpRes.content as { type: string; text: string }[];
+    const envelope = JSON.parse(content[0].text) as {
+      ok: boolean;
+      data: Array<{ uri?: string; name?: string }>;
+    };
+    expect(envelope.ok).toBe(true);
+
+    // Same tiers, same names — no tier dropped or invented by the cutover.
+    // The shared op names the field `path`; the pack names it `name` (the
+    // honest `ds:name` mapping) — the values are identical.
+    expect(new Set(envelope.data.map((r) => r.name))).toEqual(
+      new Set(opResult.map((t) => t.path)),
+    );
+    // Uniform pack shape: uri + name, no bespoke `depth` field.
+    for (const row of envelope.data) {
+      expect(row.uri).toBeTruthy();
+      expect(row).not.toHaveProperty("depth");
+    }
   });
 
-  it("tier_list condensed: matches llm formatter", async () => {
+  it("tier_list condensed lists every tier under a markdown heading", async () => {
     const opResult = await listTiers(rt.store);
-    const expectedText = tierListFmt.llm(opResult);
-
     const mcpRes = await client.callTool({
       name: "tier_list",
       arguments: { condensed: true },
     });
     const body = parseCondensed(mcpRes);
-    expect(body.text).toBe(expectedText);
+
+    // The generic pack llm renderer headings by the capitalized noun: `## Tier`.
+    expect(body.text).toContain("## Tier");
+    for (const tier of opResult) {
+      expect(body.text).toContain(tier.path);
+    }
   });
 });
 
@@ -342,7 +391,7 @@ describe("modifier parity", () => {
 // Token parity
 // ---------------------------------------------------------------------------
 
-describe("token parity", () => {
+describe.skipIf(!TOKEN_READ_SURFACE_ENABLED)("token parity", () => {
   it("token_list: count matches", async () => {
     const opResult = await listTokens(rt.store);
     const mcpRes = await client.callTool({

package/src/testing/setupXdgIsolation.ts

@@ -1,11 +1,18 @@
 /**
- * Global test setup: isolate the XDG config layer.
+ * Global test setup: isolate the XDG config and data layers.
  *
  * The layered config reader consults `$XDG_CONFIG_HOME/pragma/config.json`
- * on every read, and global-first writes create it. Point XDG at a
- * per-run temp directory so tests neither observe nor pollute the
- * developer's real global configuration. Individual tests that exercise
- * XDG behavior override this value themselves.
+ * on every read, and global-first writes create it; the schema artifact
+ * writes to `$XDG_DATA_HOME/pragma/schema.graphql`. Point both at
+ * per-run temp directories so tests neither observe nor pollute the
+ * developer's real global state. Individual tests that exercise XDG
+ * behavior override these values themselves.
+ *
+ * The boot-time schema artifact emission is disabled globally: it would
+ * add a full ke-graphql compile to every test that drives the real CLI
+ * pipeline and print an "Updated ..." notice on first boot. Its behavior
+ * is covered directly by ensureSchemaArtifact.test.ts; tests exercising
+ * the boot hook re-enable it explicitly.
  */
 
 import { mkdtempSync } from "node:fs";
@@ -13,3 +20,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 process.env.XDG_CONFIG_HOME = mkdtempSync(join(tmpdir(), "pragma-test-xdg-"));
+process.env.XDG_DATA_HOME = mkdtempSync(
+  join(tmpdir(), "pragma-test-xdg-data-"),
+);
+process.env.PRAGMA_SCHEMA_ARTIFACT = "off";

package/src/testing/standardParityFixtures.ts

@@ -1,92 +1,35 @@
 /**
- * Standard-noun parity pilot fixtures.
+ * Standard-noun cutover parity contract.
  *
- * The built-in `standard` list/lookup read stories re-expressed as a v0
- * story-pack definition, plus the honest record of what v0 cannot yet
- * reproduce. Together they form the pilot's contract: the definition is
- * asserted byte-compatible with the built-in output where the format
- * reaches (`standardParity.test.ts`), and every remaining divergence
- * must appear in {@link PARITY_GAPS} rather than being papered over.
- */
-
-import type { StoryPackDefinition } from "../domains/shared/stories/pack/types.js";
-
-/**
- * The built-in `standard` stories as a declarative pack definition.
+ * The hand-written `standard` domain was deleted; the noun is served by
+ * the bundled pack-v1 definition (`pack/bundled/standardPack.ts`), and
+ * `standardParity.test.ts` asserts SEMANTIC parity against the real
+ * @canonical/code-standards graphs: same entities and values reachable,
+ * uniform pack row/entity shapes, generic renderers.
  *
- * The list SELECT mirrors the query `listStandards` sends the store,
- * with variables renamed to the built-in's output fields (`?standard` →
- * `?uri`, `?categoryName` → `?category`) so pack rows carry the same
- * keys as the built-in summary items. The lookup mirrors the built-in
- * title and inline fields as far as v0 reaches — {@link PARITY_GAPS}
- * lists what it cannot express.
+ * {@link PARITY_GAPS} is the honest record of the differences that
+ * remain BY DESIGN after the cutover. Each entry names a concrete,
+ * accepted divergence from the deleted built-in — remove an entry only
+ * when the pack format gains the capability and the parity test asserts
+ * it.
  */
-export const STANDARD_PACK_STORY: StoryPackDefinition = {
-  noun: "standard",
-  description: "List all code standards",
-  list: {
-    query: [
-      "SELECT ?uri ?name ?category ?description",
-      "WHERE {",
-      "  ?uri a cs:CodeStandard ;",
-      "       cs:name ?name ;",
-      "       cs:description ?description .",
-      "  OPTIONAL {",
-      "    ?uri cs:hasCategory ?cat .",
-      "    ?cat cs:slug ?category .",
-      "  }",
-      "}",
-      "ORDER BY ?name",
-    ].join("\n"),
-    columns: [
-      { field: "uri", label: "IRI" },
-      { field: "name", label: "Name" },
-      { field: "category", label: "Category" },
-      { field: "description", label: "Description" },
-    ],
-  },
-  lookup: {
-    type: "cs:CodeStandard",
-    by: "cs:name",
-    fields: [
-      {
-        name: "category",
-        property: "cs:hasCategory/cs:slug",
-        label: "Category",
-      },
-      {
-        name: "description",
-        property: "cs:description",
-        label: "Description",
-      },
-      { name: "extends", property: "cs:extends", label: "Extends" },
-    ],
-  },
-};
 
 /**
- * Every place the v0 pack format cannot reproduce the built-in standard
- * stories — the pilot's primary output. Each entry names the concrete
- * missing pack-format capability; remove an entry only when the format
- * gains the capability and the parity test asserts it.
+ * Accepted post-cutover divergences from the deleted built-in standard
+ * domain. These are doctrine (semantic parity, not byte parity) plus the
+ * capabilities pack v1 deliberately does not carry.
  */
 export const PARITY_GAPS: readonly string[] = [
-  "list params: packs declare no story parameters, so the built-in --category and --search filters (and their MCP tool arguments) cannot be expressed",
-  "list disclosure: no digest/detailed progressive-disclosure levels — the built-in --digest/--detailed flags enrich rows with extends/example/dos/donts and add disclosure meta to the MCP envelope; pack lists always render summary rows",
-  "list empty guard: the built-in raises EMPTY_RESULTS with an install-hint recovery when no standards load; the pack format has no emptyError hook, so a pack list renders nothing",
-  "list plain template: packs render the shared aligned-column table; the built-in renders stacked `name [category]` blocks with an indented description — v0 columns carry no layout or template control",
-  "list llm template: pack headings are `## <Noun> (<count>)` with `` `iri` — **name** value | value `` items; the built-in emits `## Standards` with `- **name** [category]` plus an indented description line — heading text and item template are not authorable",
-  "lookup uri field: the entity IRI cannot be declared as an inline field — v0 fields are property-derived, and a field named `uri` generates a duplicate ?uri SELECT variable the store rejects; the built-in renders `URI: cs:...` as its first lookup field",
-  "lookup property paths: `category` needs the two-hop path cs:hasCategory/cs:slug; the documented v0 `property` contract is a single predicate, and the path only passes validation because the prefixed-name pattern rejects `/` in the first character alone — multi-hop fields need first-class support",
-  "lookup data compaction: the built-in compacts `extends` in resolved data (JSON shows `cs:ComponentFolderStructure`); pack rows keep the raw IRI, so lookup JSON diverges for standards with cs:extends (plain/llm still match because renderers compact at display time)",
-  "lookup sections: dos/donts (cs:do/cs:dont → Example nodes with description/language/code) cannot be declared — v0 sections are single-valued field/code kinds, and the generated single-row lookup query cannot collect arrays of structured code blocks",
-  "lookup detailed toggle: no detailedParam — the built-in CLI adds Do/Don't sections under --detailed and MCP defaults to detailed with a summary projection (project); a pack lookup has one fixed output shape",
-  "lookup empty placeholders: the built-in renders `Category: —` for a standard without a category; pack renderers skip empty fields — no fallback/placeholder declaration (every current standard has a category, so outputs match today)",
-  "lookup glob expansion: the built-in expands glob queries (e.g. `react/*`) via expandLookupQueries before resolving; pack lookups pass names through verbatim",
-  "lookup by IRI: the built-in resolves an IRI or prefixed name (e.g. `cs:ComponentProps`) as the query; a pack lookup only matches the `by` property's string value, and only case-insensitively — exact-match semantics are not selectable",
-  "lookup recovery copy: built-in not-found errors carry cross-domain hints and the recovery message `List available standards.`; pack errors generate `List available standard entries.` — recovery copy is not authorable",
-  "lookup descriptions and examples: the pack lookup CLI description, tool description, names description, and examples are generated from the noun; the built-in curates all of them (e.g. `Look up detailed information for a standard by name or IRI`)",
-  "ink renderers: the built-in stories declare renderInk TUI views; the pack format has none",
-  "extra verbs: the standard noun also ships `categories` and `sample` commands; v0 packs compile only list and lookup",
-  "noun cutover: a pack story cannot register the noun `standard` while the built-in exists (reserved-noun guard in collectPackStories), so cutover must remove the built-in stories in the same release",
+  "list disclosure: pack lists are single-level — the old `standard list --digest/--detailed` row enrichment (extends/example/dos/donts merged into every row, disclosure meta on the MCP envelope) is gone; the same data is reachable per-entity via `standard lookup --detail digest|detailed` and `standard sample`",
+  "list empty guard: the old list raised EMPTY_RESULTS with an install-hint recovery when no standards load or a --category matched nothing; the pack format has no emptyError hook, so an empty or fully-filtered list renders zero rows successfully",
+  "lookup digest rendering: the old list digest truncated the first do-example to 120 chars; the pack `digest` level fetches the full `dos` expand instead (richer, not byte-equal)",
+  "lookup data compaction: the old domain compacted cs:extends in resolved data (JSON showed `cs:ComponentFolderStructure`); pack entities keep the raw IRI in JSON — plain/llm output still compacts at display time",
+  "lookup recovery copy: cross-domain hints (detectCrossDomain) and the curated `List available standards.` message are not authorable; pack misses carry ranked suggestions with the generic `List available standard entries.` copy",
+  'typed shapes: pack rows/entities are all-string records — category counts are strings, and dos/donts entries are `{caption?, language?, code?}` string records rather than typed CodeBlock objects (no `language: "typescript"` default, absent captions are omitted)',
+  "render templates: plain/llm output uses the generic pack renderers (aligned columns, `## Standard (n)` headings, `- key: value` collection entries), not the old bespoke standard templates",
+  "sample count flag: the pack sample takes a positional count (`standard sample 3`) instead of the old `--count 3` flag",
+  "lookup IRI display: plain/llm lookup output does not print the entity IRI (the pack renderer titles by name and projects no uri field); the IRI stays reachable via the list's IRI column, `--format json`, and the non-condensed MCP envelope",
+  "categories JSON shape: the old CategorySummary carried a numeric `standardCount`; pack category rows carry the key `count` with a string value (all-string pack rows, until pack v2 typed columns)",
+  "sample population: totalCount counts name-addressable standards (the set the sampler can actually resolve) rather than all list rows; the old op counted every list row but failed outright when it drew a standard without cs:name",
+  "ink renderers: the pack format declares no renderInk TUI views",
 ];

package/src/testing/store.ts

@@ -2,12 +2,12 @@
  * Test store bridge — createTestStore, PragmaTestStoreOptions.
  *
  * Wraps `@canonical/ke/testing` with pragma's default prefix map
- * pre-configured so test authors do not need to repeat PREFIX_MAP.
+ * pre-configured so test authors do not need to repeat DEFAULT_PREFIX_MAP.
  */
 
 import type { TestStoreOptions, TestStoreResult } from "@canonical/ke/testing";
 import { createTestStore as keCreateTestStore } from "@canonical/ke/testing";
-import { PREFIX_MAP } from "../domains/shared/prefixes.js";
+import { DEFAULT_PREFIX_MAP } from "../domains/shared/prefixes.js";
 
 /** Options for creating a test store, with pragma prefixes pre-applied. */
 interface PragmaTestStoreOptions extends Omit<TestStoreOptions, "prefixes"> {
@@ -18,7 +18,7 @@ interface PragmaTestStoreOptions extends Omit<TestStoreOptions, "prefixes"> {
  * Create a test ke store with pragma's default prefix map.
  *
  * @param options - Optional overrides; additional prefixes are merged
- *   on top of the default PREFIX_MAP.
+ *   on top of the default DEFAULT_PREFIX_MAP.
  * @returns The test store result from ke/testing.
  *
  * @note Impure
@@ -29,7 +29,7 @@ async function createTestStore(
   return keCreateTestStore({
     ...options,
     prefixes: {
-      ...PREFIX_MAP,
+      ...DEFAULT_PREFIX_MAP,
       ...options.prefixes,
     },
   });

package/src/domains/create/commands/component.test.ts

@@ -1,166 +0,0 @@
-import type { CommandContext, CommandDefinition } from "@canonical/cli-core";
-import { describe, expect, it } from "vitest";
-import { PragmaError } from "#error";
-import buildComponentCommand from "./component.js";
-
-const ctx: CommandContext = {
-  cwd: "/tmp",
-  globalFlags: { llm: false, format: "text" as const, verbose: false },
-};
-
-const llmCtx: CommandContext = {
-  cwd: "/tmp",
-  globalFlags: { llm: true, format: "text" as const, verbose: false },
-};
-
-const jsonCtx: CommandContext = {
-  cwd: "/tmp",
-  globalFlags: { llm: false, format: "json" as const, verbose: false },
-};
-
-async function executeOutput(
-  cmd: CommandDefinition,
-  params: Record<string, unknown>,
-  context: CommandContext,
-): Promise<{ value: unknown; text: string }> {
-  const result = await cmd.execute(params, context);
-  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("buildComponentCommand", () => {
-  it("has correct path", () => {
-    const cmd = buildComponentCommand();
-    expect(cmd.path).toEqual(["create", "component"]);
-  });
-
-  it("includes framework as positional required select parameter", () => {
-    const cmd = buildComponentCommand();
-    const framework = cmd.parameters.find((p) => p.name === "framework");
-    expect(framework).toBeDefined();
-    expect(framework?.positional).toBe(true);
-    expect(framework?.required).toBe(true);
-    expect(framework?.type).toBe("select");
-    expect(framework?.choices?.map((c) => c.value)).toEqual([
-      "react",
-      "svelte",
-      "lit",
-    ]);
-  });
-
-  it("includes prompt-derived parameters", () => {
-    const cmd = buildComponentCommand();
-    const names = cmd.parameters.map((p) => p.name);
-    expect(names).toContain("componentPath");
-    expect(names).toContain("withStyles");
-    expect(names).toContain("withStories");
-    expect(names).toContain("withSsrTests");
-  });
-
-  it("includes execution-mode parameters", () => {
-    const cmd = buildComponentCommand();
-    const names = cmd.parameters.map((p) => p.name);
-    expect(names).toContain("dryRun");
-    expect(names).toContain("yes");
-    expect(names).toContain("showFiles");
-    expect(names).toContain("preview");
-    expect(names).toContain("generatedStamp");
-  });
-
-  it("dry-run with react returns output with file paths", async () => {
-    const cmd = buildComponentCommand();
-    const { text } = await executeOutput(
-      cmd,
-      {
-        framework: "react",
-        componentPath: "src/components/Button",
-        dryRun: true,
-        yes: true,
-      },
-      ctx,
-    );
-    expect(text).toContain("Button");
-    expect(text).toContain("src/components/Button");
-  });
-
-  it("dry-run with svelte returns output with svelte files", async () => {
-    const cmd = buildComponentCommand();
-    const { text } = await executeOutput(
-      cmd,
-      {
-        framework: "svelte",
-        componentPath: "src/lib/components/Toggle",
-        dryRun: true,
-        yes: true,
-      },
-      ctx,
-    );
-    expect(text).toContain("Toggle");
-    expect(text).toContain("src/lib/components/Toggle");
-  });
-
-  it("LLM mode returns markdown", async () => {
-    const cmd = buildComponentCommand();
-    const { text } = await executeOutput(
-      cmd,
-      {
-        framework: "react",
-        componentPath: "src/components/Card",
-      },
-      llmCtx,
-    );
-    // LLM markdown output includes generator name header
-    expect(text).toContain("component/react");
-  });
-
-  it("JSON mode returns parseable JSON", async () => {
-    const cmd = buildComponentCommand();
-    const { text } = await executeOutput(
-      cmd,
-      {
-        framework: "react",
-        componentPath: "src/components/Card",
-      },
-      jsonCtx,
-    );
-    const data = JSON.parse(text);
-    expect(data.generator.name).toBe("component/react");
-    expect(Array.isArray(data.plan)).toBe(true);
-  });
-
-  it("throws PragmaError for invalid framework", async () => {
-    const cmd = buildComponentCommand();
-    await expect(cmd.execute({ framework: "angular" }, ctx)).rejects.toThrow(
-      PragmaError,
-    );
-  });
-
-  it("throws PragmaError when framework is missing", async () => {
-    const cmd = buildComponentCommand();
-    await expect(cmd.execute({}, ctx)).rejects.toThrow(PragmaError);
-  });
-
-  it("returns interactive result when required answers are missing", async () => {
-    const cmd = buildComponentCommand();
-    // framework provided but componentPath has a default, so it should NOT
-    // trigger interactive mode — all prompts have defaults
-    const result = await cmd.execute({ framework: "lit", dryRun: true }, ctx);
-    // componentPath has a default, so executeGenerator applies it and proceeds
-    expect(result.tag).toBe("output");
-  });
-
-  it("has parameter groups", () => {
-    const cmd = buildComponentCommand();
-    expect(cmd.parameterGroups).toEqual({
-      Component: ["componentPath"],
-      Options: ["withStyles", "withStories", "withSsrTests"],
-    });
-  });
-
-  it("has examples in meta", () => {
-    const cmd = buildComponentCommand();
-    expect(cmd.meta?.examples?.length).toBeGreaterThan(0);
-  });
-});