@canonical/pragma-cli 0.30.0 → 0.32.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 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 src/components/Button",
-        "pragma create component svelte src/lib/components/Toggle",
-        "pragma create component lit src/lib/Accordion",
-        "pragma create component react 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/create/index.ts

@@ -1,15 +0,0 @@
-/** @module Create domain -- generator commands for `pragma create` (component and package). */
-
-import type { CommandDefinition } from "@canonical/cli-core";
-import { componentCommand, packageCommand } from "./commands/index.js";
-
-/**
- * Return all create command definitions.
- *
- * @returns An array of CommandDefinitions for component and package generators.
- */
-export function commands(): CommandDefinition[] {
-  return [componentCommand(), packageCommand()];
-}
-
-export { specs as mcpSpecs } from "./mcp/index.js";

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

@@ -1,2 +0,0 @@
-/** @module Create domain MCP barrel — create_component, create_package. */
-export { default as specs } from "./specs.js";

package/src/domains/create/mcp/specs.ts

@@ -1,168 +0,0 @@
-/**
- * MCP tool specs for create domain — create_component, create_package.
- */
-
-import { executeGenerator } from "@canonical/cli-core";
-import type { AnyGenerator } from "@canonical/summon-core";
-import { generators as packageGenerators } from "@canonical/summon-package";
-import { PragmaError } from "#error";
-import type { ToolSpec } from "../../shared/ToolSpec.js";
-import { COMPONENT_GENERATORS } from "../generators.js";
-
-const specs: readonly ToolSpec[] = [
-  {
-    name: "create_component",
-    description:
-      "Generate a design system component with TypeScript, tests, stories, and styles. Returns a JSON generation plan (dry-run).",
-    params: {
-      framework: {
-        type: "string",
-        description: "Component framework",
-        optional: false,
-        enum: ["react", "svelte", "lit"],
-      },
-      componentPath: {
-        type: "string",
-        description:
-          "Path for the component directory (e.g. 'src/components/Button')",
-        optional: false,
-      },
-      withStyles: {
-        type: "boolean",
-        description: "Include CSS styles (default: true)",
-        optional: true,
-      },
-      withStories: {
-        type: "boolean",
-        description: "Include Storybook stories (default: true)",
-        optional: true,
-      },
-      withSsrTests: {
-        type: "boolean",
-        description: "Include SSR tests (default: true)",
-        optional: true,
-      },
-    },
-    readOnly: false,
-    destructive: false,
-    async execute(rt, params) {
-      const batchCtx = {
-        cwd: rt.cwd,
-        globalFlags: {
-          llm: false,
-          format: "json" as const,
-          verbose: false,
-        },
-      };
-
-      const framework = params.framework as string;
-      const gen = COMPONENT_GENERATORS[framework];
-      if (!gen) {
-        throw PragmaError.invalidInput("framework", framework, {
-          validOptions: Object.keys(COMPONENT_GENERATORS),
-        });
-      }
-
-      const genParams: Record<string, unknown> = {
-        componentPath: params.componentPath,
-        ...(params.withStyles !== undefined && {
-          withStyles: params.withStyles,
-        }),
-        ...(params.withStories !== undefined && {
-          withStories: params.withStories,
-        }),
-        ...(params.withSsrTests !== undefined && {
-          withSsrTests: params.withSsrTests,
-        }),
-      };
-
-      const result = await executeGenerator(gen, genParams, batchCtx);
-      if (result.tag === "output") {
-        const text = result.render.plain(result.value);
-        return { data: JSON.parse(text) };
-      }
-
-      throw PragmaError.invalidInput(
-        "componentPath",
-        String(params.componentPath),
-      );
-    },
-  },
-  {
-    name: "create_package",
-    description:
-      "Generate a new npm package with proper configuration. Returns a JSON generation plan (dry-run).",
-    params: {
-      name: {
-        type: "string",
-        description: "Full package name (e.g. '@canonical/my-package')",
-        optional: false,
-      },
-      type: {
-        type: "string",
-        description: "Package type",
-        optional: false,
-        enum: ["tool-ts", "library", "css"],
-      },
-      description: {
-        type: "string",
-        description: "Package description",
-        optional: true,
-      },
-      withReact: {
-        type: "boolean",
-        description: "Add React dependencies (default: false)",
-        optional: true,
-      },
-      withStorybook: {
-        type: "boolean",
-        description: "Add Storybook config (default: false)",
-        optional: true,
-      },
-      withCli: {
-        type: "boolean",
-        description: "Add CLI entry point (default: false)",
-        optional: true,
-      },
-    },
-    readOnly: false,
-    destructive: false,
-    async execute(rt, params) {
-      const batchCtx = {
-        cwd: rt.cwd,
-        globalFlags: {
-          llm: false,
-          format: "json" as const,
-          verbose: false,
-        },
-      };
-
-      const gen = packageGenerators.package as AnyGenerator | undefined;
-      if (!gen) throw PragmaError.internalError("Package generator not found");
-
-      const genParams: Record<string, unknown> = {
-        name: params.name,
-        type: params.type,
-        ...(params.description !== undefined && {
-          description: params.description,
-        }),
-        ...(params.withReact !== undefined && { withReact: params.withReact }),
-        ...(params.withStorybook !== undefined && {
-          withStorybook: params.withStorybook,
-        }),
-        ...(params.withCli !== undefined && { withCli: params.withCli }),
-        runInstall: false,
-      };
-
-      const result = await executeGenerator(gen, genParams, batchCtx);
-      if (result.tag === "output") {
-        const text = result.render.plain(result.value);
-        return { data: JSON.parse(text) };
-      }
-
-      throw PragmaError.invalidInput("name", String(params.name));
-    },
-  },
-];
-
-export default specs;

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

@@ -1,75 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const { selectFormatterMock, runChecksMock } = vi.hoisted(() => ({
-  selectFormatterMock: vi.fn(
-    () => (data: { passed: number }) => `passed=${data.passed}`,
-  ),
-  runChecksMock: vi.fn(),
-}));
-
-vi.mock("../../shared/formatters.js", () => ({
-  selectFormatter: selectFormatterMock,
-}));
-
-vi.mock("../operations/index.js", () => ({
-  runChecks: runChecksMock,
-}));
-
-import doctorCommand from "./doctor.js";
-
-describe("doctorCommand", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.exitCode = undefined;
-  });
-
-  it("has path ['doctor']", () => {
-    expect(doctorCommand.path).toEqual(["doctor"]);
-  });
-
-  it("has a description", () => {
-    expect(doctorCommand.description).toBeTruthy();
-  });
-
-  it("has no parameters", () => {
-    expect(doctorCommand.parameters).toEqual([]);
-  });
-
-  it("has an execute function", () => {
-    expect(typeof doctorCommand.execute).toBe("function");
-  });
-
-  it("returns formatted output without setting an error exit code when checks pass", async () => {
-    runChecksMock.mockResolvedValue({ checks: [], passed: 2, failed: 0 });
-
-    const result = await doctorCommand.execute(
-      {},
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: false, format: "text", verbose: false },
-      },
-    );
-
-    expect(runChecksMock).toHaveBeenCalledWith({ cwd: "/workspace" });
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      expect(result.render.plain(result.value)).toBe("passed=2");
-    }
-    expect(process.exitCode).toBeUndefined();
-  });
-
-  it("sets exitCode when checks fail", async () => {
-    runChecksMock.mockResolvedValue({ checks: [], passed: 1, failed: 1 });
-
-    await doctorCommand.execute(
-      {},
-      {
-        cwd: "/workspace",
-        globalFlags: { llm: true, format: "json", verbose: false },
-      },
-    );
-
-    expect(selectFormatterMock).toHaveBeenCalled();
-    expect(process.exitCode).toBe(1);
-  });
-});

package/src/domains/doctor/commands/doctor.ts

@@ -1,43 +0,0 @@
-import type { CommandContext } from "@canonical/cli-core";
-import {
-  type CommandDefinition,
-  type CommandResult,
-  createOutputResult,
-} from "@canonical/cli-core";
-import { selectFormatter } from "../../shared/formatters.js";
-import { doctorFormatters } from "../formatters/index.js";
-import { runChecks } from "../operations/index.js";
-
-/**
- * `pragma doctor` command definition.
- *
- * Runs all environment health checks (Node version, pragma installation,
- * config file, ke store, shell completions, MCP, skills)
- * and sets exit code 1 when any check fails.
- *
- * @note Impure
- */
-const doctorCommand: CommandDefinition = {
-  path: ["doctor"],
-  description: "Check environment health",
-  parameters: [],
-  meta: {
-    examples: ["pragma doctor"],
-  },
-  execute: async (
-    _params: Record<string, unknown>,
-    ctx: CommandContext,
-  ): Promise<CommandResult> => {
-    const data = await runChecks({ cwd: ctx.cwd });
-
-    if (data.failed > 0) {
-      process.exitCode = 1;
-    }
-
-    return createOutputResult(data, {
-      plain: selectFormatter(ctx, doctorFormatters),
-    });
-  },
-};
-
-export default doctorCommand;

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

@@ -1,2 +0,0 @@
-/** @module Doctor command definitions. */
-export { default as doctorCommand } from "./doctor.js";

package/src/domains/doctor/formatters/doctor.test.ts

@@ -1,117 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { DoctorData } from "../operations/types.js";
-import formatters from "./doctor.js";
-
-const allPass: DoctorData = {
-  checks: [
-    { name: "Node version", status: "pass", detail: "v24.1.0" },
-    {
-      name: "pragma version",
-      status: "pass",
-      detail: "v0.18.0 (installed via bun, global)",
-    },
-    { name: "pragma.config.json", status: "pass", detail: "found" },
-    {
-      name: "ke store",
-      status: "pass",
-      detail: "12,847 triples in 180ms",
-    },
-  ],
-  passed: 4,
-  failed: 0,
-  skipped: 0,
-};
-
-const mixed: DoctorData = {
-  checks: [
-    { name: "Node version", status: "pass", detail: "v24.1.0" },
-    {
-      name: "pragma.config.json",
-      status: "fail",
-      detail: "not found",
-      remedy: "pragma config tier <tier>",
-    },
-    {
-      name: "skills",
-      status: "skip",
-      detail: "no harnesses detected",
-    },
-    {
-      name: "Shell completions",
-      status: "fail",
-      detail: "not installed",
-      remedy: "pragma setup completions",
-    },
-  ],
-  passed: 1,
-  failed: 2,
-  skipped: 1,
-};
-
-describe("doctor formatters", () => {
-  describe("plain", () => {
-    it("renders passing checks with ✓", () => {
-      const output = formatters.plain(allPass);
-      expect(output).toContain("✓");
-      expect(output).toContain("Node version");
-      expect(output).toContain("v24.1.0");
-    });
-
-    it("renders failing checks with ✗ and remedies at the bottom", () => {
-      const output = formatters.plain(mixed);
-      expect(output).toContain("✗");
-      expect(output).toContain("pragma config tier <tier>");
-      expect(output).toContain("pragma setup completions");
-    });
-
-    it("renders skipped checks with ○", () => {
-      const output = formatters.plain(mixed);
-      expect(output).toContain("○");
-      expect(output).toContain("skills");
-    });
-
-    it("does not render remedies section when all pass", () => {
-      const output = formatters.plain(allPass);
-      expect(output).not.toContain("Run ");
-    });
-  });
-
-  describe("llm", () => {
-    it("renders Markdown with ## Doctor heading", () => {
-      const output = formatters.llm(allPass);
-      expect(output).toContain("## Doctor");
-    });
-
-    it("renders checks as bullet list", () => {
-      const output = formatters.llm(allPass);
-      expect(output).toContain("- ✓ **Node version**: v24.1.0");
-    });
-
-    it("includes remedial section for failures", () => {
-      const output = formatters.llm(mixed);
-      expect(output).toContain("### Remedial");
-      expect(output).toContain("`pragma config tier <tier>`");
-      expect(output).toContain("`pragma setup completions`");
-    });
-  });
-
-  describe("json", () => {
-    it("returns valid JSON matching the data shape", () => {
-      const output = formatters.json(allPass);
-      const parsed = JSON.parse(output);
-      expect(parsed.passed).toBe(4);
-      expect(parsed.failed).toBe(0);
-      expect(parsed.checks).toHaveLength(4);
-    });
-
-    it("includes remedy fields for failed checks", () => {
-      const output = formatters.json(mixed);
-      const parsed = JSON.parse(output);
-      const failedChecks = parsed.checks.filter(
-        (c: { status: string }) => c.status === "fail",
-      );
-      expect(failedChecks).toHaveLength(2);
-      expect(failedChecks[0].remedy).toBeDefined();
-    });
-  });
-});