create-ailk 0.4.0 → 0.6.0

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

@@ -16,15 +16,26 @@
  * shape the inline schema parsed pre-relocation.
  */
 
-import { readFileSync } from "node:fs";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
 import { resolve, join } from "node:path";
 
+import { READINESS_SCAN_TYPES } from "@working-theory/aeo";
+
 import {
   auditInputSchema,
   auditOutputSchema,
   purchaseInputSchema,
 } from "@working-theory/validation";
 
+import { buildSinglePageAuditInput } from "../src/lib/audit-single-page.js";
+import { readStripeTaxSignal } from "../src/lib/stripe-tax-signal.js";
 import { ailkAudit } from "../src/tools/audit.js";
 
 const REPO_ROOT = resolve(__dirname, "../../..");
@@ -152,10 +163,7 @@ describe("ailkAudit handler — slug input", () => {
 describe("ailkAudit handler — url input (same-origin)", () => {
   it("returns audit result for a same-origin URL", async () => {
     const result = (await withBaseUrl(TEST_BASE_URL, () =>
-      ailkAudit(
-        { url: `${TEST_BASE_URL}/HomePage/home` },
-        CONTENT_ROOT,
-      ),
+      ailkAudit({ url: `${TEST_BASE_URL}/HomePage/home` }, CONTENT_ROOT),
     )) as Awaited<ReturnType<typeof ailkAudit>>;
     expect(typeof result.score).toBe("number");
     expect(result.perPage[0].slug).toBe("home");
@@ -204,14 +212,135 @@ describe("structural guards", () => {
 describe("purchaseInputSchema relocated to @working-theory/validation", () => {
   it("parses the same shape the inline schema parsed pre-relocation", () => {
     const result = purchaseInputSchema.safeParse({
-      priceId: "price_test_123",
+      productCode: "price_test_123",
       quantity: 2,
     });
     expect(result.success).toBe(true);
   });
 
-  it("rejects an empty priceId", () => {
-    const result = purchaseInputSchema.safeParse({ priceId: "" });
+  it("rejects an empty productCode", () => {
+    const result = purchaseInputSchema.safeParse({ productCode: "" });
     expect(result.success).toBe(false);
   });
 });
+
+// ── #5949 — the agent-readiness rules on the MCP audit path ───────────────────
+
+const T1_ROOT = resolve(
+  __dirname,
+  "../../../packages/aeo/__tests__/fixtures/t1-site",
+);
+const T1_CONTENT_ROOT = join(T1_ROOT, "content");
+
+const READINESS_RULE_IDS = [
+  "policies-present",
+  "offer-on-priced-page",
+  "tax-code-when-stripe-tax",
+];
+
+describe("audit — readiness rules (#5949)", () => {
+  it("AC-1: the T1 fixture site passes all three through the MCP tool", async () => {
+    const result = await ailkAudit(
+      { slug: "widget", type: "Product" },
+      T1_CONTENT_ROOT,
+      T1_ROOT,
+    );
+    for (const id of READINESS_RULE_IDS) {
+      const row = result.perRule.find((r) => r.ruleId === id);
+      expect(row).toBeDefined();
+      expect(row!.status).toBe("pass");
+    }
+  });
+
+  it("the tool's rule set is 9 rows and still validates against auditOutputSchema", async () => {
+    const result = await ailkAudit(
+      { slug: "widget", type: "Product" },
+      T1_CONTENT_ROOT,
+      T1_ROOT,
+    );
+    expect(result.perRule).toHaveLength(9);
+    expect(auditOutputSchema.safeParse(result).success).toBe(true);
+  });
+
+  it("D5: the site scan is the five READINESS_SCAN_TYPES and no more", async () => {
+    const input = await buildSinglePageAuditInput(
+      { slug: "widget", type: "Product" },
+      T1_CONTENT_ROOT,
+      T1_ROOT,
+    );
+    const scanned = new Set(input.readiness!.sitePages.map((p) => p.type));
+    expect([...scanned].sort()).toEqual([...READINESS_SCAN_TYPES].sort());
+    // The fixture publishes a HomePage; it is deliberately outside the universe.
+    expect(scanned.has("HomePage")).toBe(false);
+    expect(input.readiness!.sitePages.find((p) => p.slug === "widget")).toEqual(
+      {
+        slug: "widget",
+        type: "Product",
+        price: 49,
+        taxCode: "txcd_99999999",
+      },
+    );
+  });
+
+  it("D5 fail-open-to-pass: a site the scan finds nothing in yields sitePages: [] and three passes", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "ailk-mcp-readiness-"));
+    try {
+      mkdirSync(join(dir, "content", "en", "HomePage"), { recursive: true });
+      writeFileSync(
+        join(dir, "content", "en", "HomePage", "index.mdx"),
+        [
+          "---",
+          'type: "HomePage"',
+          'slug: "index"',
+          'title: "Nothing for sale"',
+          'description: "A site the readiness scan finds no priced page in."',
+          "---",
+          "",
+          "Body.",
+        ].join("\n"),
+        "utf8",
+      );
+
+      const input = await buildSinglePageAuditInput(
+        { slug: "index", type: "HomePage" },
+        join(dir, "content"),
+        dir,
+      );
+      expect(input.readiness!.sitePages).toEqual([]);
+
+      const result = await ailkAudit(
+        { slug: "index", type: "HomePage" },
+        join(dir, "content"),
+        dir,
+      );
+      for (const id of READINESS_RULE_IDS) {
+        expect(result.perRule.find((r) => r.ruleId === id)!.status).toBe(
+          "pass",
+        );
+      }
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("the projectRoot seam defaults to cwd when omitted (existing call sites unchanged)", async () => {
+    const result = await ailkAudit(
+      { slug: "home", type: "HomePage" },
+      CONTENT_ROOT,
+    );
+    expect(result.perRule).toHaveLength(9);
+    expect(auditOutputSchema.safeParse(result).success).toBe(true);
+  });
+});
+
+describe("readStripeTaxSignal — wiring smoke test (#6012)", () => {
+  // Not a duplicate of packages/aeo's own loadCommerceConfig suite (which
+  // covers the reader's parse/extract arms in isolation, against synthetic
+  // tmpdirs): this proves the EXPORTED apps/mcp wrapper itself is wired
+  // correctly — the directory probe delegating to loadCommerceConfig — against
+  // a real fixture file, since #6012 deleted the rest of this describe block
+  // as duplicate coverage but nothing else here exercises readStripeTaxSignal.
+  it("reads the T1 fixture's own project.yaml — Stripe Tax on", () => {
+    expect(readStripeTaxSignal(T1_ROOT)).toBe(true);
+  });
+});

package/templates/apps/mcp/__tests__/catalog-drift.test.ts

@@ -9,6 +9,10 @@
  * What this asserts:
  *   - Tool names registered on the McpServer == catalog tool names
  *   - Tool descriptions registered on the McpServer == catalog descriptions
+ *   - …UNDER BOTH commerce-claim states (#5971). The claim is what makes
+ *     `start_purchase` visible, so comparing a claimed server against an
+ *     unclaimed catalog (or vice versa) would compare unlike surfaces and
+ *     report drift that isn't there — or, worse, miss drift that is.
  *
  * What this does NOT assert:
  *   - inputSchema equality — the server registers Zod schemas; the catalog
@@ -16,8 +20,14 @@
  *     (packages/validation), but distinct shapes downstream by design.
  */
 
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { getMcpToolCatalog } from "@working-theory/metadata";
 
+import {
+  __setMcpCommerceClaimForTest,
+  resetMcpCommerceClaim,
+  type McpCommerceClaim,
+} from "../src/lib/commerce-claim.js";
 import { createMcpServer } from "../src/server.js";
 
 interface RegisteredTool {
@@ -31,43 +41,76 @@ interface RegisteredTool {
 // registers.
 const PAID_MODULES = "scheduling,content-write,signal-collectors";
 
-describe("MCP catalog ↔ server drift", () => {
-  const priorEnabledModules = process.env.AILK_ENABLED_MODULES;
+/**
+ * The SDK exposes no public API for listing a server's tools without a live
+ * transport, so this reads the `_registeredTools` field directly. Pinned to
+ * @modelcontextprotocol/sdk ^1.29.0 — if the SDK renames the field, change it
+ * here once rather than at each call site.
+ */
+function registeredToolsOf(
+  server: McpServer,
+): Record<string, RegisteredTool> {
+  return (
+    // eslint-disable-next-line no-restricted-syntax -- #506/#507: the SDK exposes no public accessor; the double assertion is confined to this one helper
+    server as unknown as { _registeredTools: Record<string, RegisteredTool> }
+  )._registeredTools;
+}
+
+/** The catalog options a given claim state implies — the same mapping
+ * `server.ts` applies internally, so both surfaces are read like for like. */
+function catalogOptionsFor(claim: McpCommerceClaim) {
+  return { addons: { commerce: claim === "claimed" } };
+}
+
+describe.each<McpCommerceClaim>(["unclaimed", "claimed"])(
+  "MCP catalog ↔ server drift — commerce claim %s",
+  (claim) => {
+    const priorEnabledModules = process.env.AILK_ENABLED_MODULES;
+
+    beforeEach(() => {
+      process.env.AILK_ENABLED_MODULES = PAID_MODULES;
+      __setMcpCommerceClaimForTest(claim);
+    });
+
+    afterEach(() => {
+      resetMcpCommerceClaim();
+    });
+
+    afterAll(() => {
+      if (priorEnabledModules === undefined) {
+        delete process.env.AILK_ENABLED_MODULES;
+      } else {
+        process.env.AILK_ENABLED_MODULES = priorEnabledModules;
+      }
+    });
 
-  beforeEach(() => {
-    process.env.AILK_ENABLED_MODULES = PAID_MODULES;
-  });
+    it("registered tool names equal catalog tool names", () => {
+      const registered = registeredToolsOf(createMcpServer());
+      const registeredNames = Object.keys(registered).sort();
+      const catalogNames = getMcpToolCatalog(catalogOptionsFor(claim))
+        .map((t) => t.name)
+        .sort();
+      expect(registeredNames).toEqual(catalogNames);
+    });
 
-  afterAll(() => {
-    if (priorEnabledModules === undefined) {
-      delete process.env.AILK_ENABLED_MODULES;
-    } else {
-      process.env.AILK_ENABLED_MODULES = priorEnabledModules;
-    }
-  });
+    it("registered tool descriptions equal catalog descriptions", () => {
+      const registered = registeredToolsOf(createMcpServer());
+      for (const entry of getMcpToolCatalog(catalogOptionsFor(claim))) {
+        expect(registered[entry.name]).toBeDefined();
+        expect(registered[entry.name]!.description).toBe(entry.description);
+      }
+    });
 
-  it("registered tool names equal catalog tool names", () => {
-    const server = createMcpServer();
-    const registered = (
-      // eslint-disable-next-line no-restricted-syntax -- #506/#507: pre-existing test-hygiene violation
-      server as unknown as { _registeredTools: Record<string, RegisteredTool> }
-    )._registeredTools;
-    const registeredNames = Object.keys(registered).sort();
-    const catalogNames = getMcpToolCatalog()
-      .map((t) => t.name)
-      .sort();
-    expect(registeredNames).toEqual(catalogNames);
-  });
+    it("start_purchase appears in both surfaces exactly when the claim is held", () => {
+      const registered = registeredToolsOf(createMcpServer());
+      const expected = claim === "claimed";
 
-  it("registered tool descriptions equal catalog descriptions", () => {
-    const server = createMcpServer();
-    const registered = (
-      // eslint-disable-next-line no-restricted-syntax -- #506/#507: pre-existing test-hygiene violation
-      server as unknown as { _registeredTools: Record<string, RegisteredTool> }
-    )._registeredTools;
-    for (const entry of getMcpToolCatalog()) {
-      expect(registered[entry.name]).toBeDefined();
-      expect(registered[entry.name]!.description).toBe(entry.description);
-    }
-  });
-});
+      expect("start_purchase" in registered).toBe(expected);
+      expect(
+        getMcpToolCatalog(catalogOptionsFor(claim)).some(
+          (t) => t.name === "start_purchase",
+        ),
+      ).toBe(expected);
+    });
+  },
+);

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

@@ -9,8 +9,15 @@
  * - Output validates against getOfferingsOutputSchema
  */
 
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 
 import {
   ailkGetOfferings,
@@ -88,3 +95,105 @@ describe("architectural guard — no console calls", () => {
     expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
   });
 });
+
+/**
+ * The offering fields on the catalog surface (#5838, spec 5465 D13/FR14).
+ *
+ * `get_offerings` is the one place an agent reads every Product and Service
+ * listing, so it returns the listing card's own fields — the provider, the
+ * categories, and the price when there is one — rather than leaving a caller to
+ * parse body copy for them. A listing with no price returns `null` for both
+ * money fields; it never fabricates a zero.
+ */
+describe("ailkGetOfferings — offering fields (#5838)", () => {
+  const mkdtemp = (): string =>
+    mkdtempSync(join(tmpdir(), "ailk-offerings-"));
+
+  function writeFixture(root: string): void {
+    mkdirSync(join(root, "en", "Product"), { recursive: true });
+    mkdirSync(join(root, "en", "Service"), { recursive: true });
+    writeFileSync(
+      join(root, "en", "Product", "standard.mdx"),
+      [
+        "---",
+        "type: Product",
+        "slug: standard",
+        "title: Standard",
+        "description: The flagship marketing template.",
+        "summary: A marketing site with docs, scheduling and flows.",
+        "thumbnail: /templates/standard.png",
+        "template: marketing-site",
+        "provider:",
+        "  name: SalesSmyth",
+        "  logo: /logomark.svg",
+        "categories:",
+        "  - technology",
+        "  - legal",
+        "---",
+        "",
+        "Body copy.",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(
+      join(root, "en", "Service", "launch.mdx"),
+      [
+        "---",
+        "type: Service",
+        "slug: launch",
+        "title: Launch Service",
+        "description: A productized two-week deploy.",
+        "provider:",
+        "  name: SalesSmyth",
+        "price: 2495",
+        "priceCurrency: USD",
+        "categories:",
+        "  - technology",
+        "---",
+        "",
+        "Body copy.",
+        "",
+      ].join("\n"),
+    );
+  }
+
+  let root: string;
+
+  beforeAll(() => {
+    root = mkdtemp();
+    writeFixture(root);
+  });
+
+  afterAll(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("returns provider, categories and a null price for a listing with no price", async () => {
+    const result = await ailkGetOfferings({ type: "product" }, root);
+    const standard = result.offerings.find((o) => o.name === "Standard");
+    expect(standard).toBeDefined();
+    expect(standard?.provider).toEqual({
+      name: "SalesSmyth",
+      logo: "/logomark.svg",
+    });
+    expect(standard?.categories).toEqual(["technology", "legal"]);
+    expect(standard?.price).toBeNull();
+    expect(standard?.priceCurrency).toBeNull();
+  });
+
+  it("returns the price and currency for a listing that carries them", async () => {
+    const result = await ailkGetOfferings({ type: "service" }, root);
+    const launch = result.offerings.find((o) => o.name === "Launch Service");
+    expect(launch?.price).toBe(2495);
+    expect(launch?.priceCurrency).toBe("USD");
+    expect(launch?.provider).toEqual({ name: "SalesSmyth" });
+  });
+
+  it("returns a null provider and an empty categories array for a page carrying neither", async () => {
+    const result = await ailkGetOfferings({}, CONTENT_ROOT);
+    for (const offering of result.offerings) {
+      expect(offering.provider === null || typeof offering.provider === "object").toBe(true);
+      expect(Array.isArray(offering.categories)).toBe(true);
+    }
+  });
+});

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

@@ -9,8 +9,15 @@
  * - Output validates against getPricingOutputSchema
  */
 
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
 
 import {
   ailkGetPricing,
@@ -78,3 +85,76 @@ describe("architectural guard — no console calls", () => {
     expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
   });
 });
+
+/**
+ * The offering-field fallback (#5838, spec 5465 D13/FR14).
+ *
+ * A listing page carries its price in frontmatter rather than hand-rolling an
+ * `Offer` into `schema`, so `get_pricing` reads that shape when the page
+ * authors no offer of its own. An authored offer still wins — this is a
+ * fallback, not a replacement — and a listing with no price at all still
+ * answers `null`.
+ */
+describe("ailkGetPricing — offering-field fallback (#5838)", () => {
+  let root: string;
+
+  beforeAll(() => {
+    root = mkdtempSync(join(tmpdir(), "ailk-pricing-"));
+    mkdirSync(join(root, "en", "Product"), { recursive: true });
+    writeFileSync(
+      join(root, "en", "Product", "priced.mdx"),
+      [
+        "---",
+        "type: Product",
+        "slug: priced",
+        "title: Standard",
+        "description: The flagship marketing template.",
+        "summary: A marketing site with docs, scheduling and flows.",
+        "price: 249",
+        "priceCurrency: USD",
+        "---",
+        "",
+        "Body copy.",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(
+      join(root, "en", "Product", "free.mdx"),
+      [
+        "---",
+        "type: Product",
+        "slug: free",
+        "title: Standard (Free)",
+        "description: The free marketing template.",
+        "summary: A marketing site, free forever.",
+        "---",
+        "",
+        "Body copy.",
+        "",
+      ].join("\n"),
+    );
+  });
+
+  afterAll(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  it("returns one tier from the page's own price and priceCurrency", async () => {
+    const result = await ailkGetPricing({ slug: "priced" }, root);
+    expect(result).toEqual({
+      tiers: [
+        {
+          name: "Standard",
+          price: 249,
+          priceCurrency: "USD",
+          description: "A marketing site with docs, scheduling and flows.",
+        },
+      ],
+    });
+  });
+
+  it("returns null for a listing that declares no price — never a fabricated zero", async () => {
+    const result = await ailkGetPricing({ slug: "free" }, root);
+    expect(result).toBeNull();
+  });
+});