@canonical/pragma-cli 0.30.0 → 0.32.0

package/src/domains/config/commands/framework.ts

@@ -1,91 +0,0 @@
-import {
-  type CommandDefinition,
-  type CommandResult,
-  createOutputResult,
-} from "@canonical/cli-core";
-import { runTask } from "@canonical/task/node";
-import { readConfig } from "#config";
-import type { PragmaContext } from "../../shared/context.js";
-import { selectFormatter } from "../../shared/formatters.js";
-import { frameworkFormatters } from "../formatters/index.js";
-import { validateFramework } from "../operations/index.js";
-import { setFrameworkTask } from "../tasks/index.js";
-import { resolveConfigScope, SCOPE_PARAMETERS } from "./configScope.js";
-
-/**
- * Build the `pragma config framework` command definition.
- *
- * Sets the preferred UI framework (`react` | `svelte` | `lit`). The value is
- * currently advisory only — no behaviour reads it yet; it is persisted for
- * future framework-defaulting. Supports set, reset, and query (no argument).
- *
- * @param ctx - Pragma context providing cwd and formatter selection.
- * @returns The command definition for `pragma config framework`.
- * @note - Impure — validates framework and writes config to disk.
- */
-export default function buildFrameworkCommand(
-  ctx: PragmaContext,
-): CommandDefinition {
-  return {
-    path: ["config", "framework"],
-    description: "Set or reset the preferred UI framework (advisory)",
-    parameters: [
-      {
-        name: "value",
-        description: "Framework (react, svelte, lit)",
-        type: "string",
-        positional: true,
-      },
-      {
-        name: "reset",
-        description: "Reset framework to default (none)",
-        type: "boolean",
-        default: false,
-      },
-      ...SCOPE_PARAMETERS,
-    ],
-    meta: {
-      examples: [
-        "pragma config framework react",
-        "pragma config framework --reset",
-      ],
-      extendedHelp:
-        "Advisory only for now: the value is persisted but no command reads it yet. Reserved for future framework defaulting.",
-    },
-    execute: async (
-      params: Record<string, unknown>,
-    ): Promise<CommandResult> => {
-      const scope = resolveConfigScope(params);
-      const reset = params.reset === true;
-      const value = params.value as string | undefined;
-
-      if (reset) {
-        const result = await runTask(
-          setFrameworkTask(ctx.cwd, undefined, scope),
-        );
-        const format = selectFormatter(ctx, frameworkFormatters.reset);
-        return createOutputResult(
-          { field: "framework", path: result.path },
-          { plain: format },
-        );
-      }
-
-      if (!value) {
-        const config = readConfig(ctx.cwd);
-        const format = selectFormatter(ctx, frameworkFormatters.query);
-        return createOutputResult(config.framework ?? "none", {
-          plain: format,
-        });
-      }
-
-      const framework = validateFramework(value);
-
-      const result = await runTask(setFrameworkTask(ctx.cwd, framework, scope));
-      const format = selectFormatter(ctx, frameworkFormatters.set);
-      return createOutputResult(
-        { field: "framework", value: framework, path: result.path },
-        { plain: format },
-      );
-    },
-  };
-}

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

@@ -1,6 +0,0 @@
-/** @module Config command definitions for `pragma config`. */
-export { default as channelCommand } from "./channel.js";
-export { default as frameworkCommand } from "./framework.js";
-export { default as showCommand } from "./show.js";
-export { default as tierCommand } from "./tier.js";
-export { default as traceCommand } from "./trace.js";

package/src/domains/config/commands/show.test.ts

@@ -1,61 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { Store } from "@canonical/ke";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import type { PragmaContext } from "../../shared/context.js";
-import buildShowCommand from "./show.js";
-
-function makeCtx(cwd: string): PragmaContext {
-  return {
-    cwd,
-    globalFlags: { llm: false, format: "text" as const, verbose: false },
-    store: {} as Store,
-    config: { tier: undefined, channel: "normal" },
-  };
-}
-
-describe("config show command", () => {
-  let dir: string;
-
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "pragma-cmd-show-"));
-  });
-
-  afterEach(() => {
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  it("renders show output with defaults", async () => {
-    const ctx = makeCtx(dir);
-    const cmd = buildShowCommand(ctx);
-    const result = await cmd.execute({}, ctx);
-
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      const text = result.render.plain(result.value);
-      expect(text).toContain("tier: (none — all tiers visible)");
-      expect(text).toContain("channel: normal (stable)");
-      expect(text).toContain("config file: (not found)");
-    }
-  });
-
-  it("renders show output with configured values", async () => {
-    writeFileSync(
-      join(dir, "pragma.config.json"),
-      '{"tier":"apps/lxd","channel":"experimental"}',
-    );
-
-    const ctx = makeCtx(dir);
-    const cmd = buildShowCommand(ctx);
-    const result = await cmd.execute({}, ctx);
-
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      const text = result.render.plain(result.value);
-      expect(text).toContain("tier: apps/lxd (global → apps → apps/lxd)");
-      expect(text).toContain("channel: experimental (stable + experimental)");
-      expect(text).toContain("config file:");
-    }
-  });
-});

package/src/domains/config/commands/show.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 { configShowStory } from "../stories.js";
-
-/** Wire the `pragma config show` CLI command from the config show story. */
-export default function buildShowCommand(
-  ctx: PragmaContext,
-): CommandDefinition {
-  return compileReadCommand(ctx, configShowStory);
-}

package/src/domains/config/commands/tier.test.ts

@@ -1,95 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { Store } from "@canonical/ke";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { readConfig } from "#config";
-import type { PragmaContext } from "../../shared/context.js";
-import buildTierCommand from "./tier.js";
-
-function makeCtx(cwd: string): PragmaContext {
-  return {
-    cwd,
-    globalFlags: { llm: false, format: "text" as const, verbose: false },
-    store: {} as Store,
-    config: { tier: undefined, channel: "normal" },
-  };
-}
-
-describe("config tier command", () => {
-  let dir: string;
-  let xdgDir: string;
-  let originalXdg: string | undefined;
-
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "pragma-cmd-tier-"));
-    // Bound the config walk at the fixture root, seed an empty project
-    // file so writes stay local, and isolate the global XDG layer.
-    mkdirSync(join(dir, ".git"));
-    writeFileSync(join(dir, "pragma.config.json"), "{}");
-    originalXdg = process.env.XDG_CONFIG_HOME;
-    xdgDir = mkdtempSync(join(tmpdir(), "pragma-cmd-tier-xdg-"));
-    process.env.XDG_CONFIG_HOME = xdgDir;
-  });
-
-  afterEach(() => {
-    process.env.XDG_CONFIG_HOME = originalXdg;
-    rmSync(dir, { recursive: true, force: true });
-    rmSync(xdgDir, { recursive: true, force: true });
-  });
-
-  it("resets tier via --reset flag", async () => {
-    writeFileSync(
-      join(dir, "pragma.config.json"),
-      '{"tier":"apps/lxd","channel":"normal"}',
-    );
-
-    const ctx = makeCtx(dir);
-    const cmd = buildTierCommand(ctx);
-    const result = await cmd.execute({ reset: true }, ctx);
-
-    expect(result.tag).toBe("output");
-    const config = readConfig(dir);
-    expect(config.tier).toBeUndefined();
-    expect(config.channel).toBe("normal");
-  });
-
-  it("renders reset output", async () => {
-    const ctx = makeCtx(dir);
-    const cmd = buildTierCommand(ctx);
-    const result = await cmd.execute({ reset: true }, ctx);
-
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      const text = result.render.plain(result.value);
-      expect(text).toContain("Reset tier to default.");
-    }
-  });
-
-  it("shows current tier when no args", async () => {
-    writeFileSync(join(dir, "pragma.config.json"), '{"tier":"apps"}');
-
-    const ctx = makeCtx(dir);
-    const cmd = buildTierCommand(ctx);
-    const result = await cmd.execute({}, ctx);
-
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      expect(result.value).toBe("apps");
-      const text = result.render.plain(result.value);
-      expect(text).toBe("Current tier: apps");
-    }
-  });
-
-  it("shows no tier message when none set", async () => {
-    const ctx = makeCtx(dir);
-    const cmd = buildTierCommand(ctx);
-    const result = await cmd.execute({}, ctx);
-
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      const text = result.render.plain(result.value);
-      expect(text).toBe("No tier set (all tiers visible).");
-    }
-  });
-});

package/src/domains/config/commands/tier.ts

@@ -1,84 +0,0 @@
-import {
-  type CommandDefinition,
-  type CommandResult,
-  createOutputResult,
-} from "@canonical/cli-core";
-import { runTask } from "@canonical/task/node";
-import { readConfig } from "#config";
-import type { PragmaContext } from "../../shared/context.js";
-import { selectFormatter } from "../../shared/formatters.js";
-import { tierFormatters } from "../formatters/index.js";
-import { validateTier } from "../operations/index.js";
-import { setTierTask } from "../tasks/index.js";
-import { resolveConfigScope, SCOPE_PARAMETERS } from "./configScope.js";
-
-/**
- * Build the `pragma config tier` command definition.
- *
- * Supports three modes: set a tier path (validated against the ontology),
- * reset to default, or query the current tier.
- *
- * @param ctx - Pragma context providing cwd, store, and formatter selection.
- * @returns The command definition for `pragma config tier`.
- * @note - Impure — validates tier against the ke store and writes config to disk.
- */
-export default function buildTierCommand(
-  ctx: PragmaContext,
-): CommandDefinition {
-  return {
-    path: ["config", "tier"],
-    description: "Set or reset the active tier",
-    parameters: [
-      {
-        name: "path",
-        description: "Tier path (e.g., global, apps, apps/lxd)",
-        type: "string",
-        positional: true,
-      },
-      {
-        name: "reset",
-        description: "Reset tier to default (all tiers visible)",
-        type: "boolean",
-        default: false,
-      },
-      ...SCOPE_PARAMETERS,
-    ],
-    meta: {
-      examples: ["pragma config tier apps/lxd", "pragma config tier --reset"],
-    },
-    execute: async (
-      params: Record<string, unknown>,
-    ): Promise<CommandResult> => {
-      const scope = resolveConfigScope(params);
-      const reset = params.reset === true;
-      const tierPath = params.path as string | undefined;
-
-      if (reset) {
-        const result = await runTask(setTierTask(ctx.cwd, undefined, scope));
-        const format = selectFormatter(ctx, tierFormatters.reset);
-        return createOutputResult(
-          { field: "tier", path: result.path },
-          { plain: format },
-        );
-      }
-
-      if (!tierPath) {
-        const config = readConfig(ctx.cwd);
-        const format = selectFormatter(ctx, tierFormatters.query);
-        return createOutputResult(config.tier, {
-          plain: format,
-        });
-      }
-
-      // Validate tier against ontology
-      await validateTier(ctx.store, tierPath);
-
-      const result = await runTask(setTierTask(ctx.cwd, tierPath, scope));
-      const format = selectFormatter(ctx, tierFormatters.set);
-      return createOutputResult(
-        { field: "tier", value: tierPath, path: result.path },
-        { plain: format },
-      );
-    },
-  };
-}

package/src/domains/config/commands/trace.test.ts

@@ -1,165 +0,0 @@
-import {
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { Store } from "@canonical/ke";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { readConfig } from "#config";
-import type { PragmaContext } from "../../shared/context.js";
-import buildTraceCommand from "./trace.js";
-
-function makeCtx(cwd: string): PragmaContext {
-  return {
-    cwd,
-    globalFlags: { llm: false, format: "text" as const, verbose: false },
-    store: {} as Store,
-    config: { tier: undefined, channel: "normal" },
-  };
-}
-
-describe("config trace command", () => {
-  let dir: string;
-  let xdgDir: string;
-  let originalXdg: string | undefined;
-
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "pragma-cmd-trace-"));
-    // Bound the config walk at the fixture root, seed an empty project
-    // file so writes stay local, and isolate the global XDG layer.
-    mkdirSync(join(dir, ".git"));
-    writeFileSync(join(dir, "pragma.config.json"), "{}");
-    originalXdg = process.env.XDG_CONFIG_HOME;
-    xdgDir = mkdtempSync(join(tmpdir(), "pragma-cmd-trace-xdg-"));
-    process.env.XDG_CONFIG_HOME = xdgDir;
-  });
-
-  afterEach(() => {
-    process.env.XDG_CONFIG_HOME = originalXdg;
-    rmSync(dir, { recursive: true, force: true });
-    rmSync(xdgDir, { recursive: true, force: true });
-  });
-
-  it("enables tracing", async () => {
-    const ctx = makeCtx(dir);
-    const cmd = buildTraceCommand(ctx);
-    const result = await cmd.execute({ value: "on" }, ctx);
-
-    expect(result.tag).toBe("output");
-    expect(readConfig(dir).trace).toBe(true);
-  });
-
-  it("disables tracing", async () => {
-    writeFileSync(join(dir, "pragma.config.json"), '{"trace":true}');
-
-    const ctx = makeCtx(dir);
-    const cmd = buildTraceCommand(ctx);
-    const result = await cmd.execute({ value: "off" }, ctx);
-
-    expect(result.tag).toBe("output");
-    expect(readConfig(dir).trace).toBe(false);
-  });
-
-  it("renders enable output", async () => {
-    const ctx = makeCtx(dir);
-    const cmd = buildTraceCommand(ctx);
-    const result = await cmd.execute({ value: "on" }, ctx);
-
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      expect(result.render.plain(result.value)).toContain("Tracing enabled.");
-    }
-  });
-
-  it("shows current status when no argument", async () => {
-    writeFileSync(join(dir, "pragma.config.json"), '{"trace":true}');
-
-    const ctx = makeCtx(dir);
-    const cmd = buildTraceCommand(ctx);
-    const result = await cmd.execute({}, ctx);
-
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      expect(result.value).toBe("on");
-    }
-  });
-
-  it("reports off when unset", async () => {
-    const ctx = makeCtx(dir);
-    const cmd = buildTraceCommand(ctx);
-    const result = await cmd.execute({}, ctx);
-
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      expect(result.value).toBe("off");
-    }
-  });
-
-  it("throws INVALID_INPUT for an invalid value", async () => {
-    const ctx = makeCtx(dir);
-    const cmd = buildTraceCommand(ctx);
-    await expect(cmd.execute({ value: "yes" }, ctx)).rejects.toThrow(/trace/i);
-  });
-
-  // Regression guard for the data-loss bug: enabling/disabling trace must NOT
-  // drop other persisted config fields. `packages` is runtime-consumed, so
-  // silently discarding it on a trace toggle would break package resolution.
-  it("preserves the packages field when toggling trace", async () => {
-    writeFileSync(
-      join(dir, "pragma.config.json"),
-      JSON.stringify({
-        tier: "Apps/WPE",
-        channel: "experimental",
-        packages: [
-          "@canonical/design-system",
-          {
-            name: "@canonical/anatomy-dsl",
-            source: "git+https://github.com/canonical/anatomy-dsl.git#main",
-          },
-        ],
-      }),
-    );
-
-    const ctx = makeCtx(dir);
-    const cmd = buildTraceCommand(ctx);
-    await cmd.execute({ value: "on" }, ctx);
-
-    const config = readConfig(dir);
-    expect(config.trace).toBe(true);
-    // Every pre-existing field survives the write.
-    expect(config.tier).toBe("Apps/WPE");
-    expect(config.channel).toBe("experimental");
-    expect(config.packages).toEqual([
-      "@canonical/design-system",
-      {
-        name: "@canonical/anatomy-dsl",
-        source: "git+https://github.com/canonical/anatomy-dsl.git#main",
-      },
-    ]);
-
-    // And toggling off again still preserves them.
-    await cmd.execute({ value: "off" }, ctx);
-    const after = readConfig(dir);
-    expect(after.trace).toBe(false);
-    expect(after.packages).toHaveLength(2);
-  });
-
-  it("does not persist the default channel when toggling trace", async () => {
-    // A bare `trace on` on an empty config should not write channel:"normal"
-    // (the default), keeping the file minimal per the existing convention.
-    const ctx = makeCtx(dir);
-    const cmd = buildTraceCommand(ctx);
-    await cmd.execute({ value: "on" }, ctx);
-
-    const raw = JSON.parse(
-      readFileSync(join(dir, "pragma.config.json"), "utf-8"),
-    ) as Record<string, unknown>;
-    expect(raw.trace).toBe(true);
-    expect(raw).not.toHaveProperty("channel");
-    expect(raw).not.toHaveProperty("tier");
-  });
-});

package/src/domains/config/commands/trace.ts

@@ -1,83 +0,0 @@
-import {
-  type CommandDefinition,
-  type CommandResult,
-  createOutputResult,
-} from "@canonical/cli-core";
-import { runTask } from "@canonical/task/node";
-import { readConfig } from "#config";
-import { PragmaError } from "#error";
-import type { PragmaContext } from "../../shared/context.js";
-import { selectFormatter } from "../../shared/formatters.js";
-import { traceFormatters } from "../formatters/index.js";
-import { setTraceTask } from "../tasks/index.js";
-import { resolveConfigScope, SCOPE_PARAMETERS } from "./configScope.js";
-
-/**
- * Build the `pragma config trace` command definition.
- *
- * Supports three modes: enable (`on`), disable (`off`), or query
- * when no argument is provided.
- */
-export default function buildTraceCommand(
-  ctx: PragmaContext,
-): CommandDefinition {
-  return {
-    path: ["config", "trace"],
-    description: "Enable or disable query access tracing",
-    parameters: [
-      {
-        name: "value",
-        description: "on or off",
-        type: "string",
-        positional: true,
-      },
-      ...SCOPE_PARAMETERS,
-    ],
-    meta: {
-      examples: [
-        "pragma config trace on",
-        "pragma config trace off",
-        "pragma config trace",
-      ],
-      extendedHelp:
-        "Persists to pragma.config.json. The PRAGMA_TRACE=1 env var overrides this setting.",
-    },
-    execute: async (
-      params: Record<string, unknown>,
-    ): Promise<CommandResult> => {
-      const scope = resolveConfigScope(params);
-      const value = params.value as string | undefined;
-
-      // Query mode — no argument
-      if (!value) {
-        const config = readConfig(ctx.cwd);
-        const enabled = config.trace === true;
-        const envOverride = process.env.PRAGMA_TRACE === "1";
-        const status = envOverride
-          ? "on (PRAGMA_TRACE=1 override)"
-          : enabled
-            ? "on"
-            : "off";
-        const format = selectFormatter(ctx, traceFormatters.query);
-        return createOutputResult(status, { plain: format });
-      }
-
-      // Validate
-      if (value !== "on" && value !== "off") {
-        throw PragmaError.invalidInput("trace", value, {
-          validOptions: ["on", "off"],
-        });
-      }
-
-      // Set mode
-      const enabled = value === "on";
-      const result = await runTask(setTraceTask(ctx.cwd, enabled, scope));
-
-      const format = selectFormatter(ctx, traceFormatters.set);
-      return createOutputResult(
-        { field: "trace", value: enabled, path: result.path },
-        { plain: format },
-      );
-    },
-  };
-}

package/src/domains/config/formatters/channel.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, it } from "vitest";
-import formatters from "./channel.js";
-
-describe("channelFormatters.set", () => {
-  const data = {
-    field: "channel",
-    value: "experimental",
-    path: "/repo/pragma.config.json",
-  };
-
-  it("plain renders set message", () => {
-    expect(formatters.set.plain(data)).toBe(
-      'Set channel to "experimental".\nWrote /repo/pragma.config.json',
-    );
-  });
-
-  it("llm renders set message", () => {
-    expect(formatters.set.llm(data)).toBe(
-      'Set channel to "experimental".\nWrote /repo/pragma.config.json',
-    );
-  });
-
-  it("json returns valid JSON", () => {
-    const parsed = JSON.parse(formatters.set.json(data));
-    expect(parsed.field).toBe("channel");
-    expect(parsed.value).toBe("experimental");
-  });
-});
-
-describe("channelFormatters.reset", () => {
-  it("plain renders reset message", () => {
-    expect(
-      formatters.reset.plain({ field: "channel", path: "/repo/p.json" }),
-    ).toBe("Reset channel to default.\nWrote /repo/p.json");
-  });
-
-  it("llm renders reset message", () => {
-    expect(
-      formatters.reset.llm({ field: "channel", path: "/repo/p.json" }),
-    ).toBe("Reset channel to default.\nWrote /repo/p.json");
-  });
-
-  it("json returns valid JSON", () => {
-    const parsed = JSON.parse(
-      formatters.reset.json({ field: "channel", path: "/repo/p.json" }),
-    );
-    expect(parsed.field).toBe("channel");
-    expect(parsed.reset).toBe(true);
-  });
-});
-
-describe("channelFormatters.query", () => {
-  it("plain shows current channel", () => {
-    expect(formatters.query.plain("prerelease")).toBe(
-      "Current channel: prerelease",
-    );
-  });
-
-  it("llm shows current channel", () => {
-    expect(formatters.query.llm("prerelease")).toBe(
-      "Current channel: prerelease",
-    );
-  });
-
-  it("json returns valid JSON", () => {
-    const parsed = JSON.parse(formatters.query.json("prerelease"));
-    expect(parsed.field).toBe("channel");
-    expect(parsed.value).toBe("prerelease");
-  });
-});