@canonical/pragma-cli 0.31.0 → 0.33.0

package/src/testing/integration/agent-session.test.ts

@@ -1,148 +0,0 @@
-/**
- * Layer 4: Agent session tests.
- *
- * Multi-step journeys that walk through the decision trees the
- * orientation advertises. Each scenario simulates an agent's workflow.
- */
-
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import type { PragmaRuntime } from "../../domains/shared/runtime.js";
-import createTestMcpClient from "../helpers/createTestMcpClient.js";
-import createTestRuntime from "../helpers/createTestRuntime.js";
-
-let rt: PragmaRuntime;
-let client: Client;
-let cleanup: () => Promise<void>;
-
-beforeAll(async () => {
-  rt = await createTestRuntime();
-  const mcp = await createTestMcpClient(rt);
-  client = mcp.client;
-  cleanup = mcp.cleanup;
-});
-
-afterAll(async () => {
-  await cleanup();
-  rt.dispose();
-});
-
-function parseEnvelope(
-  result: Record<string, unknown>,
-): Record<string, unknown> {
-  const content = result.content as unknown[];
-  const first = content[0] as { type: string; text: string };
-  return JSON.parse(first.text) as Record<string, unknown>;
-}
-
-describe("agent sessions", () => {
-  it("journey: build a component", async () => {
-    // 1. Probe capabilities
-    const caps = parseEnvelope(
-      await client.callTool({ name: "capabilities", arguments: {} }),
-    );
-    expect(caps.ok).toBe(true);
-
-    // 2. Orient via LLM
-    const orientation = parseEnvelope(
-      await client.callTool({ name: "llm", arguments: {} }),
-    );
-    expect(orientation.ok).toBe(true);
-    const llmData = orientation.data as {
-      decisionTrees: { intent: string }[];
-    };
-    const buildTree = llmData.decisionTrees.find(
-      (t) => t.intent === "Build a block",
-    );
-    expect(buildTree).toBeDefined();
-
-    // 3. Discover blocks
-    const list = parseEnvelope(
-      await client.callTool({ name: "block_list", arguments: {} }),
-    );
-    const blocks = list.data as { name: string }[];
-    expect(blocks.length).toBeGreaterThan(0);
-
-    // 4. Get block detail
-    const firstBlock = blocks[0];
-    expect(firstBlock).toBeDefined();
-    if (!firstBlock) {
-      throw new Error("Expected at least one block");
-    }
-    const firstName = firstBlock.name;
-    const detail = parseEnvelope(
-      await client.callTool({
-        name: "block_lookup",
-        arguments: { names: [firstName] },
-      }),
-    );
-    expect(detail.ok).toBe(true);
-    expect(
-      (detail.data as { results: { name: string }[] }).results[0]?.name,
-    ).toBe(firstName);
-
-    // 5. Multi-query lookup reports misses without failing the request
-    const err = parseEnvelope(
-      await client.callTool({
-        name: "block_lookup",
-        arguments: { names: ["XXXXX"] },
-      }),
-    );
-    expect(err.ok).toBe(true);
-    expect((err.data as { errors: { code: string }[] }).errors[0]?.code).toBe(
-      "ENTITY_NOT_FOUND",
-    );
-  });
-
-  it("journey: audit standards", async () => {
-    // 1. List categories
-    const cats = parseEnvelope(
-      await client.callTool({ name: "standard_categories", arguments: {} }),
-    );
-    const categories = cats.data as { name: string }[];
-    expect(categories.length).toBeGreaterThan(0);
-
-    // 2. List standards in first category
-    const standards = parseEnvelope(
-      await client.callTool({
-        name: "standard_list",
-        arguments: { category: categories[0]?.name },
-      }),
-    );
-    const stdList = standards.data as { name: string }[];
-    expect(stdList.length).toBeGreaterThan(0);
-
-    // 3. Get standard detail — verify dos and donts exist
-    const detail = parseEnvelope(
-      await client.callTool({
-        name: "standard_lookup",
-        arguments: { names: [stdList[0]?.name] },
-      }),
-    );
-    expect(detail.ok).toBe(true);
-    const std = (
-      detail.data as { results: { dos: unknown[]; donts: unknown[] }[] }
-    ).results[0] as { dos: unknown[]; donts: unknown[] };
-    expect(std.dos).toBeDefined();
-    expect(std.donts).toBeDefined();
-  });
-
-  it("journey: SPARQL escape hatch", async () => {
-    // Direct SPARQL query for component names
-    const result = parseEnvelope(
-      await client.callTool({
-        name: "graph_query",
-        arguments: {
-          sparql:
-            "SELECT ?name WHERE { ?c a <https://ds.canonical.com/Component> ; <https://ds.canonical.com/name> ?name } ORDER BY ?name",
-        },
-      }),
-    );
-    expect(result.ok).toBe(true);
-    const data = result.data as { bindings: { name?: string }[] };
-    // Canonical fixture has 4 components
-    expect(data.bindings.length).toBe(4);
-    expect(data.bindings[0]?.name).toBe("Beta Widget");
-    expect(data.bindings[1]?.name).toBe("Button");
-  });
-});

package/src/testing/integration/boot.test.ts

@@ -1,105 +0,0 @@
-/**
- * Layer 1: Boot tests.
- *
- * Validates runtime creation, config resolution, and store content
- * consistency from the canonical fixture.
- */
-
-import { mkdtempSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { afterAll, describe, expect, it } from "vitest";
-import { listBlocks } from "../../domains/block/operations/index.js";
-import type { PragmaRuntime } from "../../domains/shared/runtime.js";
-import { bootPragma } from "../../domains/shared/runtime.js";
-import createTestRuntime from "../helpers/createTestRuntime.js";
-
-describe("PragmaRuntime boot", () => {
-  const runtimes: PragmaRuntime[] = [];
-
-  afterAll(() => {
-    for (const rt of runtimes) rt.dispose();
-  });
-
-  it("boots from canonical fixture", async () => {
-    const rt = await createTestRuntime();
-    runtimes.push(rt);
-
-    expect(rt.store).toBeDefined();
-    expect(rt.config.tier).toBe("global");
-    expect(rt.config.channel).toBe("normal");
-  });
-
-  it("boots in under 250ms", async () => {
-    const start = performance.now();
-    const rt = await createTestRuntime();
-    const elapsed = performance.now() - start;
-    runtimes.push(rt);
-
-    expect(elapsed).toBeLessThan(250);
-  });
-
-  it("respects filtered config for tier", async () => {
-    const rt = await createTestRuntime({ config: "filtered-config.json" });
-    runtimes.push(rt);
-
-    expect(rt.config.tier).toBe("apps/lxd");
-    expect(rt.config.channel).toBe("normal");
-  });
-
-  it("filtered config includes tier-specific components", async () => {
-    const rt = await createTestRuntime({ config: "filtered-config.json" });
-    runtimes.push(rt);
-
-    const components = await listBlocks(rt.store, rt.config);
-    const names = components.map((c) => c.name);
-    // apps/lxd tier includes LXD Panel (its own) plus inherited global components
-    expect(names).toContain("LXD Panel");
-    expect(names).toContain("Button");
-  });
-
-  it("boots with file:// package ref", async () => {
-    // Create a temp "package" with TTL in the convention structure
-    const { mkdirSync, copyFileSync, writeFileSync } = await import("node:fs");
-    const { join } = await import("node:path");
-
-    const fixturesDir = new URL("../fixtures/", import.meta.url).pathname;
-    const tmpPkg = mkdtempSync(join(tmpdir(), "pragma-ref-pkg-"));
-    const dataDir = join(tmpPkg, "data");
-    mkdirSync(dataDir, { recursive: true });
-    copyFileSync(
-      join(fixturesDir, "canonical.ttl"),
-      join(dataDir, "canonical.ttl"),
-    );
-
-    // Create a temp project dir with config pointing to the file:// package
-    const tmpProject = mkdtempSync(join(tmpdir(), "pragma-ref-project-"));
-    writeFileSync(
-      join(tmpProject, "pragma.config.json"),
-      JSON.stringify({
-        packages: [{ name: "@test/fixture", source: `file://${tmpPkg}` }],
-      }),
-    );
-
-    const rt = await bootPragma({ cwd: tmpProject });
-    runtimes.push(rt);
-
-    expect(rt.store).toBeDefined();
-    expect(rt.config.packages).toHaveLength(1);
-
-    // Clean up
-    const { rmSync } = await import("node:fs");
-    rmSync(tmpPkg, { recursive: true, force: true });
-    rmSync(tmpProject, { recursive: true, force: true });
-  });
-
-  it("two runtimes produce identical store content", async () => {
-    const rt1 = await createTestRuntime();
-    const rt2 = await createTestRuntime();
-    runtimes.push(rt1, rt2);
-
-    const r1 = await listBlocks(rt1.store, rt1.config);
-    const r2 = await listBlocks(rt2.store, rt2.config);
-
-    expect(r1).toEqual(r2);
-  });
-});

package/src/testing/integration/cli-user-stories.test.ts

@@ -1,261 +0,0 @@
-/**
- * Layer 4b: CLI user-story end-to-end tests.
- *
- * Runs the real `pragma` binary through subprocesses and validates
- * realistic user journeys against its JSON output.
- */
-
-import {
-  existsSync,
-  mkdtempSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { type CommandResult, runCommand } from "../cli.js";
-
-const tempDirs = new Set<string>();
-
-afterEach(() => {
-  for (const dir of tempDirs) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-  tempDirs.clear();
-});
-
-function createWorkspace(config?: Record<string, unknown>): string {
-  const dir = mkdtempSync(join(tmpdir(), "pragma-cli-e2e-"));
-  tempDirs.add(dir);
-
-  if (config !== undefined) {
-    writeFileSync(
-      join(dir, "pragma.config.json"),
-      `${JSON.stringify(config, null, 2)}\n`,
-      "utf-8",
-    );
-  }
-
-  return dir;
-}
-
-function expectSuccess(result: CommandResult): void {
-  expect(result.exitCode).toBe(0);
-  expect(result.stderr.trim()).toBe("");
-}
-
-function parseJson<T>(result: CommandResult): T {
-  expectSuccess(result);
-  return JSON.parse(result.stdout) as T;
-}
-
-describe("CLI user stories", () => {
-  it("story: a first-time user is greeted once and gets a global config", () => {
-    const workspace = createWorkspace();
-    const freshXdg = mkdtempSync(join(tmpdir(), "pragma-firstrun-e2e-"));
-    tempDirs.add(freshXdg);
-    const env = { XDG_CONFIG_HOME: freshXdg };
-
-    // First invocation: greeting on stderr, config created, stdout untouched.
-    const first = runCommand(["info", "--format", "json"], workspace, env);
-    expect(first.exitCode).toBe(0);
-    expect(first.stderr).toContain("pre-release pragma CLI");
-    expect(first.stderr).toContain(join(freshXdg, "pragma", "config.json"));
-    expect(() => JSON.parse(first.stdout)).not.toThrow();
-    expect(
-      JSON.parse(
-        readFileSync(join(freshXdg, "pragma", "config.json"), "utf-8"),
-      ),
-    ).toEqual({});
-
-    // Second invocation: no greeting — first-run happens once.
-    const second = runCommand(["info", "--format", "json"], workspace, env);
-    expect(second.exitCode).toBe(0);
-    expect(second.stderr.trim()).toBe("");
-  }, 40_000);
-
-  it("story: a new contributor verifies the local installation with info", () => {
-    const workspace = createWorkspace();
-
-    const result = runCommand(["info", "--format", "json"], workspace);
-    const data = parseJson<{
-      version: string;
-      pm: string;
-      installSource: string;
-      channel: string;
-      store: { tripleCount: number };
-    }>(result);
-
-    expect(data.version).toMatch(/^\d+\.\d+\.\d+/);
-    expect(data.pm).toBe("bun");
-    expect(data.installSource).toContain("local");
-    expect(data.channel).toBe("normal");
-    expect(data.store.tripleCount).toBeGreaterThan(0);
-  }, 20_000);
-
-  it("story: an explorer sees duplicate Button matches before scoping the workspace", () => {
-    const workspace = createWorkspace();
-
-    const result = runCommand(
-      ["block", "lookup", "button", "--format", "json"],
-      workspace,
-    );
-    const data = parseJson<{
-      results: { name: string; tier: string }[];
-      errors: unknown[];
-    }>(result);
-
-    expect(data.errors).toEqual([]);
-    expect(data.results.length).toBeGreaterThan(1);
-    expect(data.results.every((item) => item.name === "Button")).toBe(true);
-    expect(data.results.some((item) => item.tier === "global")).toBe(true);
-  }, 20_000);
-
-  it("story: an app engineer scopes to global and resolves Button case-insensitively", () => {
-    const workspace = createWorkspace({ tier: "global", channel: "normal" });
-
-    const configResult = runCommand(
-      ["config", "show", "--format", "json"],
-      workspace,
-    );
-    const config = parseJson<{
-      tier: string;
-      channel: string;
-      configFileExists: boolean;
-      configFilePath: string;
-    }>(configResult);
-
-    expect(config.tier).toBe("global");
-    expect(config.channel).toBe("normal");
-    expect(config.configFileExists).toBe(true);
-    expect(config.configFilePath).toContain("pragma.config.json");
-
-    const lookupResult = runCommand(
-      ["block", "lookup", "button", "--format", "json"],
-      workspace,
-    );
-    const block = parseJson<{
-      name: string;
-      tier: string;
-      uri: string;
-    }>(lookupResult);
-
-    expect(block.name).toBe("Button");
-    expect(block.tier).toBe("global");
-    expect(block.uri).toContain("global.component.button");
-  }, 20_000);
-
-  it("story: a standards auditor inspects a code rule in structured output", () => {
-    const workspace = createWorkspace();
-
-    const result = runCommand(
-      ["standard", "lookup", "code/function/purity", "--format", "json"],
-      workspace,
-    );
-    const standard = parseJson<{
-      name: string;
-      category: string;
-      description: string;
-    }>(result);
-
-    expect(standard.name).toBe("code/function/purity");
-    expect(standard.category).toBe("code");
-    expect(standard.description.toLowerCase()).toContain("pure");
-  }, 20_000);
-
-  it("story: a component author previews a React scaffold before writing files", () => {
-    const workspace = createWorkspace();
-
-    const result = runCommand(
-      [
-        "create",
-        "component",
-        "react",
-        "src/components/Button",
-        "--dry-run",
-        "--yes",
-        "--format",
-        "json",
-      ],
-      workspace,
-    );
-    const plan = parseJson<{
-      generator: { name: string };
-      answers: { componentPath: string };
-      plan: { action: string; path: string }[];
-      files: Record<string, string>;
-    }>(result);
-
-    expect(plan.generator.name).toBe("component/react");
-    expect(plan.answers.componentPath).toBe("src/components/Button");
-    expect(
-      plan.plan.some(
-        (step) =>
-          step.action === "create" &&
-          step.path === "src/components/Button/Button.tsx",
-      ),
-    ).toBe(true);
-    expect(plan.files).toHaveProperty("src/components/Button/styles.css");
-    expect(plan.files).toHaveProperty("src/components/index.ts");
-  }, 20_000);
-
-  it("story: a component author can create a React scaffold from positional args", () => {
-    const workspace = createWorkspace();
-
-    const result = runCommand(
-      ["create", "component", "react", "MySth"],
-      workspace,
-    );
-
-    expectSuccess(result);
-    expect(result.stdout).toContain("Generation complete.");
-
-    const componentFile = join(workspace, "MySth", "MySth.tsx");
-    const indexFile = join(workspace, "MySth", "index.ts");
-
-    expect(existsSync(componentFile)).toBe(true);
-    expect(existsSync(indexFile)).toBe(true);
-    expect(readFileSync(indexFile, "utf-8")).toContain("./MySth");
-  }, 20_000);
-
-  it("story: --version works at the root, noun, and verb levels", () => {
-    const workspace = createWorkspace();
-    const root = runCommand(["--version"], workspace);
-    const verb = runCommand(["block", "list", "--version"], workspace);
-
-    expectSuccess(root);
-    expectSuccess(verb);
-    expect(root.stdout.trim()).toBe(verb.stdout.trim());
-    expect(root.stdout.trim()).toMatch(/^\d+\.\d+\.\d+/);
-  }, 20_000);
-
-  it("story: an unknown verb under a known noun lists that noun's verbs", () => {
-    const workspace = createWorkspace();
-
-    const result = runCommand(["standard", "frobnicate"], workspace);
-
-    expect(result.exitCode).not.toBe(0);
-    // Errors, then defers to the category that exists.
-    expect(result.stderr).toContain("unknown command 'frobnicate'");
-    expect(result.stderr).toContain("pragma standard <verb>");
-    expect(result.stderr).toContain("list");
-    expect(result.stderr).toContain("lookup");
-  }, 20_000);
-
-  it("story: a global flag before the noun still lists that noun's verbs", () => {
-    const workspace = createWorkspace();
-
-    // `--format json` sits before the noun; the flag *value* (`json`) must not
-    // be mistaken for the noun, or no verbs would be suggested.
-    const result = runCommand(
-      ["--format", "json", "standard", "frobnicate"],
-      workspace,
-    );
-
-    expect(result.exitCode).not.toBe(0);
-    expect(result.stderr).toContain("pragma standard <verb>");
-    expect(result.stderr).toContain("lookup");
-  }, 20_000);
-});

package/src/testing/integration/cross-binary-byte-equality.test.ts

@@ -1,129 +0,0 @@
-/**
- * The P.05 byte-equality gate: `pragma create X` and `summon X` must write
- * identical bytes for the same generator invocation.
- *
- * Both binaries reduce to compositions over the shared execution core:
- * pragma's batch path is `executeGenerator` (which stamps via
- * `createStampOnEffectStart`), and summon's Ink executor runs
- * `runGeneratorTask` with the same stamp transform and the defaults prompt
- * handler. This test runs both compositions over the real generators into
- * separate directories and asserts the trees are byte-identical — stamps
- * included.
- */
-
-import {
-  mkdirSync,
-  mkdtempSync,
-  readdirSync,
-  readFileSync,
-  rmSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join, relative } from "node:path";
-import {
-  answerPromptWithDefaults,
-  createGeneratorStamp,
-  createStampOnEffectStart,
-  executeGenerator,
-  runGeneratorTask,
-} from "@canonical/cli-core";
-import { generators as componentGenerators } from "@canonical/summon-component";
-import type { GeneratorDefinition } from "@canonical/summon-core";
-import { generators as packageGenerators } from "@canonical/summon-package";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-interface Case {
-  readonly name: string;
-  readonly gen: GeneratorDefinition;
-  readonly answers: Record<string, unknown>;
-}
-
-const cases: Case[] = [
-  {
-    name: "component/react",
-    gen: componentGenerators["component/react"] as GeneratorDefinition,
-    answers: { componentPath: "src/components/Button" },
-  },
-  {
-    name: "package/library",
-    gen: packageGenerators.package as GeneratorDefinition,
-    answers: { name: "@canonical/example", type: "library" },
-  },
-];
-
-/** Collect every file under root as relative path → raw content bytes. */
-const readTree = (root: string, dir = root): Map<string, Buffer> => {
-  const files = new Map<string, Buffer>();
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      for (const [k, v] of readTree(root, full)) files.set(k, v);
-    } else {
-      files.set(relative(root, full), readFileSync(full));
-    }
-  }
-  return files;
-};
-
-describe("cross-binary byte equality — pragma create ≡ summon", () => {
-  let dir: string;
-  let originalCwd: string;
-
-  beforeEach(() => {
-    originalCwd = process.cwd();
-    dir = mkdtempSync(join(tmpdir(), "byte-equality-"));
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    rmSync(dir, { recursive: true, force: true });
-  });
-
-  for (const testCase of cases) {
-    it(`${testCase.name} — both binaries write identical bytes, stamps included`, async () => {
-      const pragmaDir = join(dir, "pragma");
-      const summonDir = join(dir, "summon");
-      mkdirSync(pragmaDir);
-      mkdirSync(summonDir);
-
-      // pragma path: the create command's batch execution (stamps by default).
-      const result = await executeGenerator(
-        testCase.gen,
-        { ...testCase.answers, yes: true },
-        {
-          cwd: pragmaDir,
-          globalFlags: { llm: false, format: "text", verbose: false },
-        },
-      );
-      expect(result.tag).toBe("output");
-
-      // summon path: the Ink executor's exact composition over the shared
-      // core. Both binaries fold prompt defaults into the answers before
-      // generating; do the same here.
-      const answers = { ...testCase.answers };
-      for (const prompt of testCase.gen.prompts) {
-        if (!(prompt.name in answers) && prompt.default !== undefined) {
-          answers[prompt.name] = prompt.default;
-        }
-      }
-      await runGeneratorTask(testCase.gen.generate(answers), {
-        cwd: summonDir,
-        promptHandler: answerPromptWithDefaults,
-        onEffectStart: createStampOnEffectStart(
-          createGeneratorStamp(testCase.gen),
-        ),
-      });
-
-      const pragmaTree = readTree(pragmaDir);
-      const summonTree = readTree(summonDir);
-
-      expect([...pragmaTree.keys()].sort()).toEqual(
-        [...summonTree.keys()].sort(),
-      );
-      for (const [path, content] of pragmaTree) {
-        expect(summonTree.get(path)?.equals(content), path).toBe(true);
-      }
-      expect(pragmaTree.size).toBeGreaterThan(0);
-    });
-  }
-});