@canonical/pragma-cli 0.30.0 → 0.32.0

package/src/pipeline/renderError.test.ts

@@ -1,151 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { PragmaError } from "../error/index.js";
-import {
-  renderErrorJson,
-  renderErrorLlm,
-  renderErrorPlain,
-} from "./renderError.js";
-
-describe("renderErrorPlain", () => {
-  it("renders a basic error", () => {
-    const err = PragmaError.internalError("something broke");
-    const out = renderErrorPlain(err);
-    expect(out).toContain("Error: Internal error: something broke");
-    expect(out).toContain("Please report this issue.");
-  });
-
-  it("renders suggestions", () => {
-    const err = PragmaError.notFound("component", "Buton", {
-      suggestions: ["Button", "ButtonGroup"],
-    });
-    const out = renderErrorPlain(err);
-    expect(out).toContain("Did you mean?");
-    expect(out).toContain("  - Button");
-    expect(out).toContain("  - ButtonGroup");
-  });
-
-  it("renders filters", () => {
-    const err = PragmaError.emptyResults("component", {
-      filters: { tier: "apps/lxd", channel: "normal" },
-    });
-    const out = renderErrorPlain(err);
-    expect(out).toContain("Active filters:");
-    expect(out).toContain("  tier: apps/lxd");
-    expect(out).toContain("  channel: normal");
-  });
-
-  it("renders validOptions", () => {
-    const err = PragmaError.invalidInput("channel", "aggressive", {
-      validOptions: ["normal", "experimental", "prerelease"],
-    });
-    const out = renderErrorPlain(err);
-    expect(out).toContain("Valid options: normal, experimental, prerelease");
-  });
-
-  it("renders recovery with cli command", () => {
-    const err = PragmaError.notFound("component", "Foo", {
-      recovery: {
-        message: "List available components.",
-        cli: "pragma block list",
-        mcp: { tool: "block_list" },
-      },
-    });
-    const out = renderErrorPlain(err);
-    expect(out).toContain("Run `pragma block list`");
-  });
-
-  it("renders recovery with message only (no cli)", () => {
-    const err = PragmaError.emptyResults("component", {
-      recovery: {
-        message: "Ensure design system packages are installed.",
-      },
-    });
-    const out = renderErrorPlain(err);
-    expect(out).toContain("Ensure design system packages are installed.");
-  });
-});
-
-describe("renderErrorLlm", () => {
-  it("renders structured markdown", () => {
-    const err = PragmaError.notFound("component", "Buton", {
-      suggestions: ["Button", "ButtonGroup"],
-      recovery: {
-        message: "List available components.",
-        cli: "pragma block list",
-        mcp: { tool: "block_list" },
-      },
-    });
-    const out = renderErrorLlm(err);
-    expect(out).toContain("## Error: ENTITY_NOT_FOUND");
-    expect(out).toContain('component "Buton" not found.');
-    expect(out).toContain("Suggestions: Button, ButtonGroup");
-    expect(out).toContain("Recovery: `pragma block list`");
-  });
-
-  it("renders filters", () => {
-    const err = PragmaError.emptyResults("component", {
-      filters: { tier: "apps/lxd" },
-    });
-    const out = renderErrorLlm(err);
-    expect(out).toContain("Filters: tier=apps/lxd");
-  });
-
-  it("renders validOptions", () => {
-    const err = PragmaError.invalidInput("channel", "bad", {
-      validOptions: ["normal", "experimental"],
-    });
-    const out = renderErrorLlm(err);
-    expect(out).toContain("Valid options: normal, experimental");
-  });
-
-  it("renders recovery message when no cli", () => {
-    const err = PragmaError.emptyResults("component", {
-      recovery: {
-        message: "Install packages first.",
-      },
-    });
-    const out = renderErrorLlm(err);
-    expect(out).toContain("Recovery: Install packages first.");
-  });
-});
-
-describe("renderErrorJson", () => {
-  it("produces valid JSON with all fields", () => {
-    const err = PragmaError.notFound("component", "Buton", {
-      suggestions: ["Button"],
-      recovery: {
-        message: "List available components.",
-        cli: "pragma block list",
-        mcp: { tool: "block_list" },
-      },
-    });
-    const parsed = JSON.parse(renderErrorJson(err));
-    expect(parsed.code).toBe("ENTITY_NOT_FOUND");
-    expect(parsed.message).toBe('component "Buton" not found.');
-    expect(parsed.entity).toEqual({ type: "component", name: "Buton" });
-    expect(parsed.suggestions).toEqual(["Button"]);
-    expect(parsed.recovery).toEqual({
-      message: "List available components.",
-      cli: "pragma block list",
-      mcp: { tool: "block_list" },
-    });
-  });
-
-  it("includes filters and validOptions", () => {
-    const err = PragmaError.emptyResults("component", {
-      filters: { tier: "global" },
-    });
-    const parsed = JSON.parse(renderErrorJson(err));
-    expect(parsed.code).toBe("EMPTY_RESULTS");
-    expect(parsed.filters).toEqual({ tier: "global" });
-  });
-
-  it("includes undefined fields as undefined/null", () => {
-    const err = PragmaError.storeError("disk full");
-    const parsed = JSON.parse(renderErrorJson(err));
-    expect(parsed.code).toBe("STORE_ERROR");
-    expect(parsed.entity).toBeUndefined();
-    expect(parsed.filters).toBeUndefined();
-    expect(parsed.validOptions).toBeUndefined();
-  });
-});

package/src/pipeline/renderError.ts

@@ -1,129 +0,0 @@
-/**
- * Error rendering functions for different output surfaces.
- *
- * Each renderer takes a PragmaError and produces a formatted string
- * suitable for its target: human-readable plain text, LLM-oriented
- * Markdown, or machine-readable JSON.
- */
-
-import type { PragmaError } from "../error/index.js";
-
-/**
- * Render a PragmaError as human-readable plain text for terminal output.
- *
- * Includes suggestions, active filters, valid options, and recovery hints
- * when present.
- *
- * @param error - The structured error to render.
- * @returns Multi-line plain text string.
- */
-function renderErrorPlain(error: PragmaError): string {
-  const lines: string[] = [];
-
-  lines.push(`Error: ${error.message}`);
-
-  if (error.suggestions.length > 0) {
-    lines.push("");
-    lines.push("Did you mean?");
-    for (const s of error.suggestions) {
-      lines.push(`  - ${s}`);
-    }
-  }
-
-  if (error.filters) {
-    lines.push("");
-    lines.push("Active filters:");
-    for (const [key, value] of Object.entries(error.filters)) {
-      lines.push(`  ${key}: ${value}`);
-    }
-  }
-
-  if (error.validOptions && error.validOptions.length > 0) {
-    lines.push("");
-    lines.push(`Valid options: ${error.validOptions.join(", ")}`);
-  }
-
-  if (error.crossDomain) {
-    lines.push("");
-    lines.push(
-      `"${error.entity?.name ?? ""}" exists as a ${error.crossDomain.entityType}.`,
-    );
-    lines.push(`Run \`${error.crossDomain.cli}\``);
-  }
-
-  if (error.recovery) {
-    lines.push("");
-    if (error.recovery.cli) {
-      lines.push(`Run \`${error.recovery.cli}\``);
-    } else {
-      lines.push(error.recovery.message);
-    }
-  }
-
-  return lines.join("\n");
-}
-
-/**
- * Render a PragmaError as condensed Markdown for LLM consumption.
- *
- * @param error - The structured error to render.
- * @returns Markdown-formatted string.
- */
-function renderErrorLlm(error: PragmaError): string {
-  const lines: string[] = [];
-
-  lines.push(`## Error: ${error.code}`);
-  lines.push(error.message);
-
-  if (error.suggestions.length > 0) {
-    lines.push(`Suggestions: ${error.suggestions.join(", ")}`);
-  }
-
-  if (error.filters) {
-    const filterParts = Object.entries(error.filters)
-      .map(([k, v]) => `${k}=${v}`)
-      .join(", ");
-    lines.push(`Filters: ${filterParts}`);
-  }
-
-  if (error.validOptions && error.validOptions.length > 0) {
-    lines.push(`Valid options: ${error.validOptions.join(", ")}`);
-  }
-
-  if (error.crossDomain) {
-    lines.push(
-      `Cross-domain: "${error.entity?.name ?? ""}" exists as a ${error.crossDomain.entityType}. \`${error.crossDomain.cli}\``,
-    );
-  }
-
-  if (error.recovery) {
-    if (error.recovery.cli) {
-      lines.push(`Recovery: \`${error.recovery.cli}\``);
-    } else {
-      lines.push(`Recovery: ${error.recovery.message}`);
-    }
-  }
-
-  return lines.join("\n");
-}
-
-/**
- * Render a PragmaError as a JSON string for machine consumption.
- *
- * @param error - The structured error to render.
- * @returns JSON-serialized string of the error payload.
- */
-function renderErrorJson(error: PragmaError): string {
-  return JSON.stringify({
-    code: error.code,
-    message: error.message,
-    entity: error.entity,
-    suggestions: error.suggestions,
-    recovery: error.recovery,
-    crossDomain: error.crossDomain,
-    filters: error.filters,
-    validOptions: error.validOptions,
-  });
-}
-
-export { renderErrorJson, renderErrorLlm, renderErrorPlain };

package/src/pipeline/resolveCommandKind.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from "vitest";
-import resolveCommandKind from "./resolveCommandKind.js";
-
-describe("resolveCommandKind", () => {
-  it("detects completions-client from --completions flag", () => {
-    const result = resolveCommandKind([
-      "node",
-      "pragma",
-      "--completions",
-      "component",
-      "li",
-    ]);
-    expect(result).toEqual({
-      kind: "completions-client",
-      partial: "component li",
-    });
-  });
-
-  it("detects completions-server from _completions-server command", () => {
-    const result = resolveCommandKind([
-      "node",
-      "pragma",
-      "_completions-server",
-    ]);
-    expect(result).toEqual({ kind: "completions-server" });
-  });
-
-  it("detects doctor command", () => {
-    const result = resolveCommandKind(["node", "pragma", "doctor"]);
-    expect(result).toEqual({ kind: "doctor" });
-  });
-
-  it("detects store-skip for setup", () => {
-    const result = resolveCommandKind(["node", "pragma", "setup"]);
-    expect(result).toEqual({ kind: "store-skip", command: "setup" });
-  });
-
-  it("detects store-skip for mcp", () => {
-    const result = resolveCommandKind(["node", "pragma", "mcp"]);
-    expect(result).toEqual({ kind: "store-skip", command: "mcp" });
-  });
-
-  it("defaults to store-required for regular commands", () => {
-    const result = resolveCommandKind(["node", "pragma", "component", "list"]);
-    expect(result).toEqual({ kind: "store-required" });
-  });
-
-  it("defaults to store-required when no command given", () => {
-    const result = resolveCommandKind(["node", "pragma"]);
-    expect(result).toEqual({ kind: "store-required" });
-  });
-
-  it("skips flags when finding command argument", () => {
-    const result = resolveCommandKind(["node", "pragma", "--llm", "doctor"]);
-    expect(result).toEqual({ kind: "doctor" });
-  });
-
-  it("skips the --format value when finding the command argument", () => {
-    const result = resolveCommandKind([
-      "node",
-      "pragma",
-      "--format",
-      "json",
-      "doctor",
-    ]);
-    expect(result).toEqual({ kind: "doctor" });
-  });
-});

package/src/pipeline/resolveCommandKind.ts

@@ -1,78 +0,0 @@
-/**
- * Classify the CLI invocation into a command kind.
- *
- * Determines which pipeline path to take before any store boot occurs.
- * Store-skip commands are listed declaratively in STORE_SKIP_COMMANDS.
- */
-
-import type { CommandKind } from "./types.js";
-
-/** Commands that do not require the ke store to be booted. */
-const STORE_SKIP_COMMANDS = new Set([
-  "setup",
-  "mcp",
-  "update-refs",
-  "capabilities",
-  "trace",
-  "graphql",
-]);
-
-function findCommandArg(argv: readonly string[]): string | undefined {
-  const args = argv.slice(2);
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (!arg) continue;
-
-    if (arg === "--format") {
-      i += 1;
-      continue;
-    }
-
-    if (arg.startsWith("-")) {
-      continue;
-    }
-
-    return arg;
-  }
-
-  return undefined;
-}
-
-/**
- * Classify the CLI invocation into a {@link CommandKind} discriminated union.
- *
- * Runs before any store boot to decide the pipeline path.
- *
- * @param argv - Raw process.argv array.
- * @returns Discriminated union indicating the command category.
- */
-export default function resolveCommandKind(
-  argv: readonly string[],
-): CommandKind {
-  // Completions client — intercept before anything else.
-  const completionsIdx = argv.indexOf("--completions");
-  if (completionsIdx !== -1) {
-    const partial = argv.slice(completionsIdx + 1).join(" ");
-    return { kind: "completions-client", partial };
-  }
-
-  const commandArg = findCommandArg(argv);
-
-  // Completions server — boots its own store with cache.
-  if (commandArg === "_completions-server") {
-    return { kind: "completions-server" };
-  }
-
-  // Doctor runs before store boot — it validates the environment itself.
-  if (commandArg === "doctor") {
-    return { kind: "doctor" };
-  }
-
-  // Store-skip commands (setup, mcp) don't need the ke store.
-  if (commandArg && STORE_SKIP_COMMANDS.has(commandArg)) {
-    return { kind: "store-skip", command: commandArg };
-  }
-
-  return { kind: "store-required" };
-}