create-ailk 0.5.0 → 0.6.1

package/templates/apps/mcp/__tests__/read_content.test.ts

@@ -8,19 +8,83 @@
  * - ailkReadContent returns null (not throws) for an unknown slug
  * - Output validates against readContentOutputSchema
  * - No console.* calls in handler (structural test)
+ * - #6030 AC-1: BlogPosting and DocsDetail — the two types this issue admits —
+ *   are readable through the adapter on both the MDX leg and the database
+ *   leg, and both are asserted against the shared adapter seam
+ *   (`ContentAdapter.getPageSource`) per the API↔MCP parity contract (D3).
  */
 
-import { readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { resolve, join } from "node:path";
 
+import {
+  createMdxAdapter,
+  resetResolvedContentAdapter,
+  type ArtifactPrismaClient,
+} from "@working-theory/content-adapters";
+
 import {
   ailkReadContent,
   readContentInputSchema,
   readContentOutputSchema,
 } from "../src/tools/read_content.js";
+import {
+  __setMcpPublicWorkspaceForTest,
+  resetMcpPublicWorkspace,
+} from "../src/lib/public-workspace.js";
 
 const REPO_ROOT = resolve(__dirname, "../../..");
 const CONTENT_ROOT = join(REPO_ROOT, "content");
+const WORKSPACE_ID = "wksp_00000000-0000-7000-8000-000000000001";
+
+/**
+ * A structural `ArtifactPrismaClient` stub (#5876 spec D11) — `artifact` and
+ * `artifactVersion` jest.fn()s, injected directly, no database.
+ */
+function makeArtifactPrismaClientStub(overrides: {
+  artifact?: { publishedVersionId: string | null } | null;
+  version?: { content: unknown } | null;
+}): ArtifactPrismaClient {
+  const artifact =
+    overrides.artifact === undefined || overrides.artifact === null
+      ? null
+      : {
+          id: "artifact_1",
+          workspaceId: WORKSPACE_ID,
+          contentType: "text/page",
+          locale: "en",
+          slug: "home",
+          title: "Home",
+          publishedVersionId: overrides.artifact.publishedVersionId,
+        };
+  const version =
+    overrides.version === undefined || overrides.version === null
+      ? null
+      : {
+          id: "version_1",
+          artifactId: "artifact_1",
+          workspaceId: WORKSPACE_ID,
+          content: overrides.version.content,
+          isCurrent: false,
+        };
+  return {
+    artifact: {
+      findFirst: jest.fn().mockResolvedValue(artifact),
+      findMany: jest.fn().mockResolvedValue([]),
+      create: jest.fn(),
+      updateMany: jest.fn(),
+      deleteMany: jest.fn(),
+    },
+    artifactVersion: {
+      findFirst: jest.fn().mockResolvedValue(version),
+      findMany: jest.fn().mockResolvedValue([]),
+      create: jest.fn(),
+      updateMany: jest.fn(),
+    },
+    $transaction: jest.fn(),
+  };
+}
 
 describe("readContentInputSchema", () => {
   it("accepts a valid type + slug", () => {
@@ -142,6 +206,263 @@ describe("ailkReadContent handler", () => {
   });
 });
 
+describe("ailkReadContent — CONTENT_ADAPTER=database (#5876)", () => {
+  const previous = process.env.CONTENT_ADAPTER;
+
+  beforeEach(() => {
+    process.env.CONTENT_ADAPTER = "database";
+    // resolveContentAdapter() memoises per (kind, workspaceId, contentRoot,
+    // defaultLocale, manifestPath) — NOT per prisma instance — so every case
+    // below (same workspaceId, same defaults) would otherwise reuse the FIRST
+    // test's adapter, bound to the FIRST test's stub.
+    resetResolvedContentAdapter();
+  });
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
+    else process.env.CONTENT_ADAPTER = previous;
+    resetMcpPublicWorkspace();
+    resetResolvedContentAdapter();
+  });
+
+  it("AC-1: returns { slug, type, frontmatter, body } for a published page", async () => {
+    const stub = makeArtifactPrismaClientStub({
+      artifact: { publishedVersionId: "version_1" },
+      version: {
+        content: {
+          type: "HomePage",
+          slug: "home",
+          title: "Home",
+          description: "The homepage.",
+          body: "# Hello",
+        },
+      },
+    });
+    __setMcpPublicWorkspaceForTest({
+      kind: "resolved",
+      workspaceId: WORKSPACE_ID,
+      prisma: stub,
+    });
+
+    const result = await ailkReadContent({ type: "HomePage", slug: "home" });
+
+    expect(result).not.toBeNull();
+    expect(result!.slug).toBe("home");
+    expect(result!.type).toBe("HomePage");
+    expect(result!.body).toBe("# Hello");
+    // The reach test (§5.2 AC-1) — the read is bound to the resolved workspace.
+    expect(stub.artifact.findFirst).toHaveBeenCalledWith(
+      expect.objectContaining({
+        where: expect.objectContaining({ workspaceId: WORKSPACE_ID }),
+      }),
+    );
+  });
+
+  it("AC-1: returns null for a draft-only artifact (no published version)", async () => {
+    const stub = makeArtifactPrismaClientStub({
+      artifact: { publishedVersionId: null },
+    });
+    __setMcpPublicWorkspaceForTest({
+      kind: "resolved",
+      workspaceId: WORKSPACE_ID,
+      prisma: stub,
+    });
+
+    const result = await ailkReadContent({ type: "HomePage", slug: "home" });
+
+    expect(result).toBeNull();
+  });
+
+  it("AC-1: returns null for an unknown slug", async () => {
+    const stub = makeArtifactPrismaClientStub({ artifact: null });
+    __setMcpPublicWorkspaceForTest({
+      kind: "resolved",
+      workspaceId: WORKSPACE_ID,
+      prisma: stub,
+    });
+
+    const result = await ailkReadContent({
+      type: "HomePage",
+      slug: "does-not-exist",
+    });
+
+    expect(result).toBeNull();
+  });
+
+  it("AC-2: returns null when the workspace is unresolved, with no content lookup", async () => {
+    const stub = makeArtifactPrismaClientStub({});
+    __setMcpPublicWorkspaceForTest({ kind: "unresolved", reason: "ambiguous" });
+
+    const result = await ailkReadContent({ type: "HomePage", slug: "home" });
+
+    expect(result).toBeNull();
+    expect(stub.artifact.findFirst).not.toHaveBeenCalled();
+  });
+});
+
+describe("ailkReadContent — BlogPosting and DocsDetail, MDX leg (#6030 AC-1)", () => {
+  let root = "";
+
+  beforeAll(() => {
+    root = mkdtempSync(join(tmpdir(), "ailk-mcp-6030-"));
+    for (const { type, slug, body } of [
+      { type: "BlogPosting", slug: "launch-post", body: "# Launch post\n\nBody." },
+      { type: "DocsDetail", slug: "getting-started", body: "# Getting started\n\nBody." },
+    ]) {
+      const dir = join(root, "en", type);
+      mkdirSync(dir, { recursive: true });
+      writeFileSync(
+        join(dir, `${slug}.mdx`),
+        [
+          "---",
+          `type: "${type}"`,
+          `slug: "${slug}"`,
+          `title: "${type} ${slug} title"`,
+          `description: "${type} ${slug} description"`,
+          "---",
+          "",
+          body,
+          "",
+        ].join("\n"),
+        "utf8",
+      );
+    }
+  });
+
+  afterAll(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it.each(["BlogPosting", "DocsDetail"] as const)(
+    "returns the page for %s, deep-equal to the projection over getPageSource (D3)",
+    async (type) => {
+      const slug = type === "BlogPosting" ? "launch-post" : "getting-started";
+      const result = await ailkReadContent({ type, slug, locale: "en" }, root);
+
+      // The shared seam D3 asserts from both ends: read_content's payload is
+      // derived from exactly what ContentAdapter.getPageSource(type, slug,
+      // locale) returns for the arguments the tool builds — not restated.
+      const adapter = createMdxAdapter({ contentRoot: root });
+      const source = await adapter.getPageSource(type, slug, "en");
+      expect(source).not.toBeNull();
+      const expected = readContentOutputSchema.parse({
+        slug: source!.frontmatter.slug ?? slug,
+        type: source!.frontmatter.type ?? type,
+        frontmatter: source!.frontmatter,
+        body: source!.body,
+      });
+
+      expect(result).toEqual(expected);
+      expect(result!.slug).toBe(slug);
+      expect(result!.type).toBe(type);
+    },
+  );
+
+  it.each(["BlogPosting", "DocsDetail"] as const)(
+    "returns null for an absent slug of %s",
+    async (type) => {
+      const result = await ailkReadContent(
+        { type, slug: "does-not-exist", locale: "en" },
+        root,
+      );
+      expect(result).toBeNull();
+    },
+  );
+});
+
+describe("ailkReadContent — BlogPosting and DocsDetail, CONTENT_ADAPTER=database (#6030 AC-1)", () => {
+  const previous = process.env.CONTENT_ADAPTER;
+
+  beforeEach(() => {
+    process.env.CONTENT_ADAPTER = "database";
+    resetResolvedContentAdapter();
+  });
+
+  afterEach(() => {
+    if (previous === undefined) delete process.env.CONTENT_ADAPTER;
+    else process.env.CONTENT_ADAPTER = previous;
+    resetMcpPublicWorkspace();
+    resetResolvedContentAdapter();
+  });
+
+  it.each(["BlogPosting", "DocsDetail"] as const)(
+    "returns { slug, type, frontmatter, body } for a published %s",
+    async (type) => {
+      const slug = "probe";
+      const stub = makeArtifactPrismaClientStub({
+        artifact: { publishedVersionId: "version_1" },
+        version: {
+          content: {
+            type,
+            slug,
+            title: `${type} title`,
+            description: `${type} description`,
+            body: "# Published body",
+          },
+        },
+      });
+      __setMcpPublicWorkspaceForTest({
+        kind: "resolved",
+        workspaceId: WORKSPACE_ID,
+        prisma: stub,
+      });
+
+      const result = await ailkReadContent({ type, slug });
+
+      expect(result).not.toBeNull();
+      expect(result!.slug).toBe(slug);
+      expect(result!.type).toBe(type);
+      expect(result!.body).toBe("# Published body");
+    },
+  );
+
+  // D4 — the publication guard must hold for every newly-admitted type, not
+  // only HomePage's existing case.
+  it.each(["BlogPosting", "DocsDetail"] as const)(
+    "returns null for a draft-only %s artifact (no published version)",
+    async (type) => {
+      const stub = makeArtifactPrismaClientStub({
+        artifact: { publishedVersionId: null },
+      });
+      __setMcpPublicWorkspaceForTest({
+        kind: "resolved",
+        workspaceId: WORKSPACE_ID,
+        prisma: stub,
+      });
+
+      const result = await ailkReadContent({ type, slug: "probe" });
+
+      expect(result).toBeNull();
+    },
+  );
+
+  // D4 — type-as-address: a page stored under a different frontmatter.type
+  // than requested reads as absent, never as a cross-type hit.
+  it("returns null when the requested type does not match the stored frontmatter.type", async () => {
+    const stub = makeArtifactPrismaClientStub({
+      artifact: { publishedVersionId: "version_1" },
+      version: {
+        content: {
+          type: "BlogPosting",
+          slug: "probe",
+          title: "A blog post",
+          description: "Stored as BlogPosting.",
+          body: "# Body",
+        },
+      },
+    });
+    __setMcpPublicWorkspaceForTest({
+      kind: "resolved",
+      workspaceId: WORKSPACE_ID,
+      prisma: stub,
+    });
+
+    const result = await ailkReadContent({ type: "DocsDetail", slug: "probe" });
+
+    expect(result).toBeNull();
+  });
+});
+
 describe("architectural guard — no console calls", () => {
   it("apps/mcp/src/tools/read_content.ts does not call console.*", () => {
     const src = readFileSync(

package/templates/apps/mcp/__tests__/search_content.test.ts

@@ -9,10 +9,13 @@
  * - ailkSearchContent happy path returns results array with correct shape
  * - ailkSearchContent returns empty results for a query with no matches
  * - Malformed input causes Zod rejection
+ * - #5831: searchContentInputSchema accepts a registry category slug and
+ *   rejects one outside the registry; the handler forwards it to the adapter
  */
 
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 
 import {
   ailkSearchContent,
@@ -100,6 +103,106 @@ describe("searchContentInputSchema", () => {
     const result = searchContentInputSchema.safeParse({});
     expect(result.success).toBe(false);
   });
+
+  it("accepts a category slug from the registry (#5831)", () => {
+    const result = searchContentInputSchema.safeParse({
+      query: "roof",
+      category: "roofing",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects a category slug outside the registry with an enum error (#5831)", () => {
+    const result = searchContentInputSchema.safeParse({
+      query: "roof",
+      category: "not-a-real-category",
+    });
+    expect(result.success).toBe(false);
+    expect(result.error!.issues[0]).toMatchObject({
+      code: "invalid_value",
+      path: ["category"],
+    });
+  });
+
+  it("rejects a GROUP slug — groups are derived, never tagged (#5831)", () => {
+    const result = searchContentInputSchema.safeParse({
+      query: "roof",
+      category: "professional-services",
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("ailkSearchContent — category filter (#5831)", () => {
+  let root = "";
+
+  beforeAll(() => {
+    root = mkdtempSync(join(tmpdir(), "ailk-mcp-category-"));
+    const dir = join(root, "en", "Product");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      join(dir, "roof-replacement.mdx"),
+      [
+        "---",
+        'type: "Product"',
+        'slug: "roof-replacement"',
+        'title: "Roof Replacement"',
+        'description: "A full roof replacement service."',
+        "categories:",
+        "  - roofing",
+        "---",
+        "",
+        "We replace a roof in a day.",
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+    writeFileSync(
+      join(dir, "attic-ventilation.mdx"),
+      [
+        "---",
+        'type: "Product"',
+        'slug: "attic-ventilation"',
+        'title: "Attic Ventilation"',
+        'description: "Ventilation that protects the roof deck."',
+        "categories:",
+        "  - hvac",
+        "---",
+        "",
+        "Attic airflow keeps a roof healthy.",
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+  });
+
+  afterAll(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("forwards category to the adapter — only the tagged page comes back", async () => {
+    const result = await ailkSearchContent(
+      { query: "roof", category: "roofing" },
+      root,
+    );
+    expect(result.results.map((r) => r.slug)).toEqual(["roof-replacement"]);
+  });
+
+  it("returns every match when no category is passed", async () => {
+    const result = await ailkSearchContent({ query: "roof" }, root);
+    expect(result.results.map((r) => r.slug).sort()).toEqual([
+      "attic-ventilation",
+      "roof-replacement",
+    ]);
+  });
+
+  it("returns [] for a registry slug nothing is tagged with", async () => {
+    const result = await ailkSearchContent(
+      { query: "roof", category: "legal" },
+      root,
+    );
+    expect(result.results).toEqual([]);
+  });
 });
 
 describe("ailkSearchContent handler", () => {

package/templates/apps/mcp/__tests__/server.test.ts

@@ -6,9 +6,10 @@
  * - list_pages and read_content tools are registered
  * - Each registered tool has a non-empty description
  *
- * Note: `start_purchase` registration is asserted in
- * `purchase-disabled.test.ts` as NOT-registered (S15a / issue #610). The
- * prior `start_purchase` assertions in this file moved there.
+ * Note: the full `start_purchase` claim MATRIX — absent on a keyless boot,
+ * present on a keyed one — is asserted in `purchase-disabled.test.ts`
+ * (#5971, superseding S15a / issue #610). The describe block at the end of
+ * this file pins the registration half from the bootstrap's own side.
  *
  * Strategy: createMcpServer() returns the McpServer instance before connecting
  * to a transport. Tests inspect server._registeredTools (plain object in SDK
@@ -17,7 +18,11 @@
  * casts below. Pinned to @modelcontextprotocol/sdk ^1.29.0.
  */
 
-import { createMcpServer } from "../src/server.js";
+import {
+  __setMcpCommerceClaimForTest,
+  resetMcpCommerceClaim,
+} from "../src/lib/commerce-claim.js";
+import { createMcpServer, listRegisteredTools } from "../src/server.js";
 
 describe("createMcpServer", () => {
   it("creates an McpServer without throwing", () => {
@@ -90,26 +95,74 @@ const I4_TOOLS = [
   "get_faq",
 ] as const;
 
-describe.each(I4_TOOLS.map((name) => [name]))("%s tool registration", (toolName) => {
-  it(`server has the ${toolName} tool registered`, () => {
+describe.each(I4_TOOLS.map((name) => [name]))(
+  "%s tool registration",
+  (toolName) => {
+    it(`server has the ${toolName} tool registered`, () => {
+      const server = createMcpServer();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
+      const tools = (server as any)._registeredTools as Record<string, unknown>;
+      expect(toolName in tools).toBe(true);
+    });
+
+    it(`${toolName} descriptor has a non-empty description`, () => {
+      const server = createMcpServer();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
+      const tools = (server as any)._registeredTools as Record<
+        string,
+        { description?: string }
+      >;
+      const tool = tools[toolName];
+      expect(tool).toBeDefined();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
+      expect(typeof (tool as any).description).toBe("string");
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
+      expect((tool as any).description.length).toBeGreaterThan(0);
+    });
+  },
+);
+
+describe("start_purchase registration — gated on the commerce claim (#5971)", () => {
+  afterEach(() => {
+    resetMcpCommerceClaim();
+  });
+
+  it("is not registered when the deployment holds no commerce claim", () => {
+    __setMcpCommerceClaimForTest("unclaimed");
     const server = createMcpServer();
     // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
     const tools = (server as any)._registeredTools as Record<string, unknown>;
-    expect(toolName in tools).toBe(true);
+
+    expect("start_purchase" in tools).toBe(false);
+    expect(listRegisteredTools().map((t) => t.name)).not.toContain(
+      "start_purchase",
+    );
   });
 
-  it(`${toolName} descriptor has a non-empty description`, () => {
+  it("is registered, with a non-empty description, when the claim is held", () => {
+    __setMcpCommerceClaimForTest("claimed");
     const server = createMcpServer();
     // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
     const tools = (server as any)._registeredTools as Record<
       string,
       { description?: string }
     >;
-    const tool = tools[toolName];
-    expect(tool).toBeDefined();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
-    expect(typeof (tool as any).description).toBe("string");
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: pre-existing test-hygiene violation
-    expect((tool as any).description.length).toBeGreaterThan(0);
+
+    expect("start_purchase" in tools).toBe(true);
+    expect(tools["start_purchase"]?.description ?? "").not.toBe("");
+  });
+
+  it("registering it never changes what the other tools do", () => {
+    __setMcpCommerceClaimForTest("unclaimed");
+    const keyless = listRegisteredTools()
+      .map((t) => t.name)
+      .sort();
+
+    __setMcpCommerceClaimForTest("claimed");
+    const keyed = listRegisteredTools()
+      .map((t) => t.name)
+      .sort();
+
+    expect(keyed).toEqual([...keyless, "start_purchase"].sort());
   });
 });