@canonical/pragma-cli 0.29.0 → 0.31.0

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);
-  });
-});

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

@@ -1,123 +0,0 @@
-import {
-  type CommandDefinition,
-  executeGenerator,
-  type ParameterDefinition,
-  promptToParameter,
-} from "@canonical/cli-core";
-import { generators } from "@canonical/summon-component";
-import { PragmaError } from "#error";
-import { COMPONENT_GENERATORS } from "../generators.js";
-
-const FRAMEWORK_CHOICES = [
-  { label: "react", value: "react" },
-  { label: "svelte", value: "svelte" },
-  { label: "lit", value: "lit" },
-] as const;
-
-/** Reference generator used to derive shared prompt parameters. */
-const referenceGenerator = generators["component/react"];
-
-/**
- * Build the `pragma create component` command definition.
- *
- * Uses a dispatch pattern: `framework` is a required positional select
- * parameter. The execute function looks up the matching generator and
- * delegates to `executeGenerator` from cli-core.
- *
- * @returns The command definition for `pragma create component`.
- * @note Impure
- */
-export default function buildComponentCommand(): CommandDefinition {
-  const frameworkParam: ParameterDefinition = {
-    name: "framework",
-    description: "Component framework (react, svelte, lit)",
-    type: "select",
-    choices: [...FRAMEWORK_CHOICES],
-    positional: true,
-    required: true,
-  };
-
-  // Derive prompt parameters from the reference generator
-  const promptParams = referenceGenerator.prompts.map(promptToParameter);
-
-  // Execution-mode parameters (same as generatorToCommand appends)
-  const execParams: ParameterDefinition[] = [
-    {
-      name: "dryRun",
-      description: "Preview without writing files",
-      type: "boolean",
-    },
-    {
-      name: "undo",
-      description: "Reverse a previously generated component",
-      type: "boolean",
-    },
-    {
-      name: "yes",
-      description: "Skip confirmation prompts",
-      type: "boolean",
-    },
-    {
-      name: "showFiles",
-      description: "Show file contents in dry-run",
-      type: "boolean",
-    },
-    {
-      name: "preview",
-      description: "Show file preview before writing",
-      type: "boolean",
-      default: true,
-    },
-    {
-      name: "generatedStamp",
-      description: "Add generated file stamps",
-      type: "boolean",
-      default: true,
-    },
-  ];
-
-  const parameters = [frameworkParam, ...promptParams, ...execParams];
-
-  return {
-    path: ["create", "component"],
-    description:
-      "Generate a component with TypeScript, tests, stories, and styles",
-    parameters,
-    execute: async (params, ctx) => {
-      const framework = params.framework as string | undefined;
-      if (!framework) {
-        throw PragmaError.invalidInput("framework", "(missing)", {
-          validOptions: ["react", "svelte", "lit"],
-          recovery: {
-            message: "Provide a framework for component generation.",
-            cli: "pragma create component react --component-path src/components/Button",
-          },
-        });
-      }
-
-      const gen = COMPONENT_GENERATORS[framework];
-      if (!gen) {
-        throw PragmaError.invalidInput("framework", framework, {
-          validOptions: Object.keys(COMPONENT_GENERATORS),
-          recovery: {
-            message: `Valid frameworks: ${Object.keys(COMPONENT_GENERATORS).join(", ")}`,
-          },
-        });
-      }
-
-      return executeGenerator(gen, params, ctx);
-    },
-    meta: {
-      examples: [
-        "pragma create component react --component-path src/components/Button",
-        "pragma create component svelte --component-path src/lib/components/Toggle",
-        "pragma create component lit --component-path src/lib/Accordion",
-        "pragma create component react --component-path src/components/Button --dry-run",
-      ],
-    },
-    parameterGroups: {
-      Component: ["componentPath"],
-      Options: ["withStyles", "withStories", "withSsrTests"],
-    },
-  };
-}

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

@@ -1,3 +0,0 @@
-/** @module Create command definitions for `pragma create`. */
-export { default as componentCommand } from "./component.js";
-export { default as packageCommand } from "./package.js";

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

@@ -1,35 +0,0 @@
-import type { CommandContext } from "@canonical/cli-core";
-import { describe, expect, it } from "vitest";
-import buildPackageCommand from "./package.js";
-
-const ctx: CommandContext = {
-  cwd: "/tmp",
-  globalFlags: { llm: false, format: "text" as const, verbose: false },
-};
-
-describe("buildPackageCommand", () => {
-  it("has correct path", () => {
-    const cmd = buildPackageCommand();
-    expect(cmd.path).toEqual(["create", "package"]);
-  });
-
-  it("dry-run with all params returns output", async () => {
-    const cmd = buildPackageCommand();
-    const result = await cmd.execute(
-      {
-        name: "@canonical/test-pkg",
-        type: "tool-ts",
-        dryRun: true,
-        yes: true,
-      },
-      ctx,
-    );
-    expect(result.tag).toBe("output");
-  });
-
-  it("with missing required params returns batch output outside a TTY", async () => {
-    const cmd = buildPackageCommand();
-    const result = await cmd.execute({}, ctx);
-    expect(result.tag).toBe("output");
-  });
-});

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

@@ -1,21 +0,0 @@
-import {
-  type CommandDefinition,
-  generatorToCommand,
-} from "@canonical/cli-core";
-import { generators as packageGenerators } from "@canonical/summon-package";
-
-/**
- * Build the `pragma create package` command definition by bridging
- * the package generator via `generatorToCommand`.
- *
- * @returns The command definition for `pragma create package`.
- * @throws Error if the package generator is not found.
- * @note Impure
- */
-export default function buildPackageCommand(): CommandDefinition {
-  const gen = packageGenerators.package;
-  if (!gen) {
-    throw new Error("Package generator not found in @canonical/summon-package");
-  }
-  return generatorToCommand(["create", "package"], gen);
-}

package/src/domains/create/generators.ts

@@ -1,8 +0,0 @@
-import { generators } from "@canonical/summon-component";
-import type { AnyGenerator } from "@canonical/summon-core";
-
-export const COMPONENT_GENERATORS: Record<string, AnyGenerator> = {
-  react: generators["component/react"],
-  svelte: generators["component/svelte"],
-  lit: generators["component/lit"],
-};

package/src/domains/standard/commands/categories.test.ts

@@ -1,70 +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 buildCategoriesCommand from "./categories.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("buildCategoriesCommand", () => {
-  it("returns categories with counts", async () => {
-    const ctx = makeCtx();
-    const cmd = buildCategoriesCommand(ctx);
-    const { text } = await executeOutput(cmd, {}, ctx);
-    expect(text).toContain("react (2 standards)");
-    expect(text).toContain("code (1 standard)");
-  });
-
-  it("renders LLM format with --llm", async () => {
-    const ctx = makeCtx({
-      globalFlags: { llm: true, format: "text" as const, verbose: false },
-    });
-    const cmd = buildCategoriesCommand(ctx);
-    const { text } = await executeOutput(cmd, {}, ctx);
-    expect(text).toContain("## Standard Categories");
-    expect(text).toContain("**react**");
-  });
-
-  it("renders JSON output", async () => {
-    const ctx = makeCtx({
-      globalFlags: { llm: false, format: "json" as const, verbose: false },
-    });
-    const cmd = buildCategoriesCommand(ctx);
-    const { text } = await executeOutput(cmd, {}, ctx);
-    const parsed = JSON.parse(text);
-    expect(Array.isArray(parsed)).toBe(true);
-    expect(parsed.some((c: { name: string }) => c.name === "react")).toBe(true);
-  });
-});

package/src/domains/standard/commands/categories.ts

@@ -1,48 +0,0 @@
-/**
- * Wires the `pragma standard categories` CLI command.
- *
- * Lists all standard categories with their standard counts. Throws a
- * structured recovery error when no categories are found.
- */
-
-import {
-  type CommandDefinition,
-  type CommandResult,
-  createOutputResult,
-} from "@canonical/cli-core";
-import { PragmaError } from "#error";
-import type { PragmaContext } from "../../shared/context.js";
-import { selectFormatter } from "../../shared/formatters.js";
-import { categoriesFormatters } from "../formatters/index.js";
-import { listCategories } from "../operations/index.js";
-
-export default function buildCategoriesCommand(
-  ctx: PragmaContext,
-): CommandDefinition {
-  return {
-    path: ["standard", "categories"],
-    description: "List all standard categories with counts",
-    parameters: [],
-    meta: {
-      examples: ["pragma standard categories"],
-    },
-    execute: async (
-      _params: Record<string, unknown>,
-    ): Promise<CommandResult> => {
-      const categories = await listCategories(ctx.store);
-
-      if (categories.length === 0) {
-        throw PragmaError.emptyResults("categories", {
-          recovery: {
-            message:
-              "Ensure code standards packages are installed: bun add -D @canonical/code-standards",
-          },
-        });
-      }
-
-      return createOutputResult(categories, {
-        plain: selectFormatter(ctx, categoriesFormatters),
-      });
-    },
-  };
-}

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

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

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

@@ -1,105 +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 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 all standards", async () => {
-    const ctx = makeCtx();
-    const cmd = buildListCommand(ctx);
-    const { text } = await executeOutput(cmd, {}, ctx);
-    expect(text).toContain("react/component/folder-structure");
-    expect(text).toContain("react/component/props");
-    expect(text).toContain("code/function/purity");
-  });
-
-  it("filters by --category", async () => {
-    const ctx = makeCtx();
-    const cmd = buildListCommand(ctx);
-    const { text } = await executeOutput(cmd, { category: "react" }, ctx);
-    expect(text).toContain("react/component/folder-structure");
-    expect(text).toContain("react/component/props");
-    expect(text).not.toContain("code/function/purity");
-  });
-
-  it("filters by --search", async () => {
-    const ctx = makeCtx();
-    const cmd = buildListCommand(ctx);
-    const { text } = await executeOutput(cmd, { search: "folder" }, ctx);
-    expect(text).toContain("react/component/folder-structure");
-    expect(text).not.toContain("code/function/purity");
-  });
-
-  it("throws EMPTY_RESULTS for non-matching filter", async () => {
-    const ctx = makeCtx();
-    const cmd = buildListCommand(ctx);
-    try {
-      await cmd.execute({ category: "nonexistent" }, ctx);
-      expect.fail("Should have thrown");
-    } catch (e) {
-      expect(e).toBeInstanceOf(PragmaError);
-      expect((e as PragmaError).code).toBe("EMPTY_RESULTS");
-    }
-  });
-
-  it("renders LLM format with --llm", 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("## Standards");
-    expect(text).toContain("**react/component/folder-structure**");
-  });
-
-  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(
-        (s: { name: string }) => s.name === "react/component/folder-structure",
-      ),
-    ).toBe(true);
-  });
-});

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

@@ -1,90 +0,0 @@
-/**
- * Wires the `pragma standard list` CLI command.
- *
- * Lists all code standards with optional category and search filters.
- * Supports progressive disclosure via `--digest` (summary + first example)
- * and `--detailed` (full dos/donts) flags.
- */
-
-import {
-  type CommandDefinition,
-  type CommandResult,
-  createOutputResult,
-} from "@canonical/cli-core";
-import { createListView } from "#tui";
-import type { PragmaContext } from "../../shared/context.js";
-import { selectFormatter } from "../../shared/formatters.js";
-import { listFormatters } from "../formatters/index.js";
-import type { StandardListOutput } from "../formatters/types.js";
-import { resolveStandardList } from "../orchestration/index.js";
-import { standardConfig } from "../standardConfig.js";
-
-export default function buildListCommand(
-  ctx: PragmaContext,
-): CommandDefinition {
-  return {
-    path: ["standard", "list"],
-    description: "List all code standards",
-    parameters: [
-      {
-        name: "category",
-        description: "Filter by category",
-        type: "string",
-      },
-      {
-        name: "search",
-        description: "Search in name and description",
-        type: "string",
-      },
-      {
-        name: "digest",
-        description: "Show description and first example for each standard",
-        type: "boolean",
-        default: false,
-      },
-      {
-        name: "detailed",
-        description: "Show full dos/donts for each standard",
-        type: "boolean",
-        default: false,
-      },
-    ],
-    meta: {
-      examples: [
-        "pragma standard list",
-        "pragma standard list --category react",
-        'pragma standard list --search "folder"',
-        "pragma standard list --digest",
-        "pragma standard list --detailed",
-        "pragma standard list --llm",
-      ],
-    },
-    execute: async (
-      params: Record<string, unknown>,
-    ): Promise<CommandResult> => {
-      const contract = await resolveStandardList(ctx, {
-        category: params.category as string | undefined,
-        search: params.search as string | undefined,
-        digest: params.digest === true,
-        detailed: params.detailed === true,
-      });
-
-      const output: StandardListOutput = {
-        items: contract.items,
-        details: contract.details,
-        disclosure: contract.disclosure,
-      };
-
-      return createOutputResult(output, {
-        plain: selectFormatter(ctx, listFormatters),
-        ink: (data) =>
-          createListView({
-            heading: "Standards",
-            domain: "standard",
-            items: data.items,
-            columns: standardConfig.listColumns,
-          }),
-      });
-    },
-  };
-}