@canonical/pragma-cli 0.18.0

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

@@ -0,0 +1,148 @@
+/**
+ * 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

@@ -0,0 +1,67 @@
+/**
+ * Layer 1: Boot tests.
+ *
+ * Validates runtime creation, config resolution, and store content
+ * consistency from the canonical fixture.
+ */
+
+import { afterAll, describe, expect, it } from "vitest";
+import { listBlocks } from "../../domains/block/operations/index.js";
+import type { PragmaRuntime } 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 100ms", async () => {
+    const start = performance.now();
+    const rt = await createTestRuntime();
+    const elapsed = performance.now() - start;
+    runtimes.push(rt);
+
+    expect(elapsed).toBeLessThan(100);
+  });
+
+  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("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);
+  });
+});