@canonical/pragma-cli 0.31.0 → 0.33.0

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

@@ -1,119 +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 buildFrameworkCommand from "./framework.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 framework command", () => {
-  let dir: string;
-  let xdgDir: string;
-  let originalXdg: string | undefined;
-
-  beforeEach(() => {
-    dir = mkdtempSync(join(tmpdir(), "pragma-cmd-framework-"));
-    // 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-framework-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("sets framework to react", async () => {
-    const ctx = makeCtx(dir);
-    const result = await buildFrameworkCommand(ctx).execute(
-      { value: "react" },
-      ctx,
-    );
-    expect(result.tag).toBe("output");
-    expect(readConfig(dir).framework).toBe("react");
-  });
-
-  it("accepts svelte and lit", async () => {
-    const ctx = makeCtx(dir);
-    await buildFrameworkCommand(ctx).execute({ value: "svelte" }, ctx);
-    expect(readConfig(dir).framework).toBe("svelte");
-    await buildFrameworkCommand(ctx).execute({ value: "lit" }, ctx);
-    expect(readConfig(dir).framework).toBe("lit");
-  });
-
-  it("rejects a value combined with --reset", async () => {
-    const ctx = makeCtx(dir);
-    await expect(
-      buildFrameworkCommand(ctx).execute({ value: "react", reset: true }, ctx),
-    ).rejects.toMatchObject({ code: "INVALID_INPUT" });
-  });
-
-  it("rejects an explicit empty-string value", async () => {
-    const ctx = makeCtx(dir);
-    await expect(
-      buildFrameworkCommand(ctx).execute({ value: "" }, ctx),
-    ).rejects.toMatchObject({ code: "INVALID_INPUT" });
-  });
-
-  it("rejects an invalid framework", async () => {
-    const ctx = makeCtx(dir);
-    await expect(
-      buildFrameworkCommand(ctx).execute({ value: "angular" }, ctx),
-    ).rejects.toThrow(/framework/i);
-  });
-
-  it("reports 'none' when unset", async () => {
-    const ctx = makeCtx(dir);
-    const result = await buildFrameworkCommand(ctx).execute({}, ctx);
-    expect(result.tag).toBe("output");
-    if (result.tag === "output") {
-      expect(result.value).toBe("none");
-    }
-  });
-
-  it("resets framework via --reset (removes the field)", async () => {
-    writeFileSync(join(dir, "pragma.config.json"), '{"framework":"react"}');
-    const ctx = makeCtx(dir);
-    await buildFrameworkCommand(ctx).execute({ reset: true }, ctx);
-    expect(readConfig(dir).framework).toBeUndefined();
-    // The field is removed, not left as a stale value.
-    const raw = JSON.parse(
-      readFileSync(join(dir, "pragma.config.json"), "utf-8"),
-    ) as Record<string, unknown>;
-    expect(raw).not.toHaveProperty("framework");
-  });
-
-  it("preserves other config fields when setting framework", async () => {
-    writeFileSync(
-      join(dir, "pragma.config.json"),
-      JSON.stringify({ tier: "Apps/WPE", trace: true }),
-    );
-    const ctx = makeCtx(dir);
-    await buildFrameworkCommand(ctx).execute({ value: "lit" }, ctx);
-    const config = readConfig(dir);
-    expect(config.framework).toBe("lit");
-    expect(config.tier).toBe("Apps/WPE");
-    expect(config.trace).toBe(true);
-  });
-});

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

@@ -1,103 +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 { 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;
-
-      // Contradictory input: a value AND --reset. Reject rather than silently
-      // letting one win.
-      if (reset && value !== undefined) {
-        throw PragmaError.invalidInput("framework", value, {
-          recovery: {
-            message: "Pass either a framework value or --reset, not both.",
-          },
-        });
-      }
-
-      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 },
-        );
-      }
-
-      // No value at all → query. An explicit empty string is invalid input.
-      if (value === undefined) {
-        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,102 +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).");
-    }
-  });
-
-  it("rejects a tier path combined with --reset", async () => {
-    const ctx = makeCtx(dir);
-    await expect(
-      buildTierCommand(ctx).execute({ path: "apps/lxd", reset: true }, ctx),
-    ).rejects.toMatchObject({ code: "INVALID_INPUT" });
-  });
-});

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

@@ -1,97 +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 { 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;
-
-      // Contradictory input: a tier path AND --reset. Reject rather than
-      // silently letting one win.
-      if (reset && tierPath !== undefined) {
-        throw PragmaError.invalidInput("tier", tierPath, {
-          recovery: {
-            message: "Pass either a tier path or --reset, not both.",
-          },
-        });
-      }
-
-      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 },
-        );
-      }
-
-      // No path at all → query. An explicit empty string is invalid input and
-      // is rejected by validateTier below.
-      if (tierPath === undefined) {
-        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");
-  });
-});