create-ailk 0.1.0

package/templates/apps/web/app/[locale]/courses/page.tsx

@@ -0,0 +1,25 @@
+// Courses list page. Reads CoursesList MDX via the content adapter and emits
+// a JSON-LD CollectionPage via the dispatcher.
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import { renderPage } from "@working-theory/page-renderer";
+import type { ReactElement } from "react";
+
+interface Props {
+  params: Promise<{ locale: string }>;
+  getMdxSource?: typeof defaultGetMdxSource;
+}
+
+export default async function Page({
+  params,
+  getMdxSource,
+}: Props): Promise<ReactElement> {
+  const { locale } = await params;
+  return renderPage({
+    type: "CoursesList",
+    slug: "courses",
+    locale,
+    translationsNamespace: "courses",
+    bodyMode: "mdx-body",
+    ...(getMdxSource !== undefined && { getMdxSource }),
+  });
+}

package/templates/apps/web/app/[locale]/dev/purchase/__tests__/actions.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Tests for purchaseAction Server Action.
+ *
+ * Acceptance criteria verified here:
+ * - purchaseAction(validInput) returns { url: string } on success
+ * - purchaseAction(invalidInput) returns Zod validation errors
+ * - purchaseAction calls @working-theory/api-client checkout helper
+ * - Parity shape: purchaseAction returns the same response shape as ailkPurchase
+ */
+
+import { purchaseAction } from "../purchase.actions.js";
+
+// Mock @working-theory/api-client
+jest.mock("@working-theory/api-client", () => ({
+  checkout: {
+    createSession: jest.fn(),
+  },
+}));
+
+import { checkout } from "@working-theory/api-client";
+const mockCreateSession = checkout.createSession as jest.Mock;
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("purchaseAction — valid input", () => {
+  it("returns { url } on success", async () => {
+    mockCreateSession.mockResolvedValueOnce({
+      ok: true,
+      body: {
+        sessionId: "cs_test_abc123",
+        url: "https://checkout.stripe.com/pay/cs_test_abc123",
+      },
+    });
+
+    const result = await purchaseAction({
+      priceId: "price_test_123",
+      quantity: 1,
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    expect(result).toEqual({
+      url: "https://checkout.stripe.com/pay/cs_test_abc123",
+    });
+  });
+
+  it("returns { url } when quantity is omitted", async () => {
+    mockCreateSession.mockResolvedValueOnce({
+      ok: true,
+      body: {
+        sessionId: "cs_test_xyz",
+        url: "https://checkout.stripe.com/pay/cs_test_xyz",
+      },
+    });
+
+    const result = await purchaseAction({
+      priceId: "price_test_abc",
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    expect(result).toEqual({
+      url: "https://checkout.stripe.com/pay/cs_test_xyz",
+    });
+  });
+
+  it("calls checkout.createSession with mapped payload", async () => {
+    mockCreateSession.mockResolvedValueOnce({
+      ok: true,
+      body: {
+        sessionId: "cs_test_def",
+        url: "https://checkout.stripe.com/pay/cs_test_def",
+      },
+    });
+
+    await purchaseAction({
+      priceId: "price_plan_pro",
+      quantity: 2,
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    expect(mockCreateSession).toHaveBeenCalledWith({
+      productCode: "price_plan_pro",
+      quantity: 2,
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+  });
+});
+
+describe("purchaseAction — invalid input (Zod errors)", () => {
+  it("returns validation errors when priceId is missing", async () => {
+    const result = await purchaseAction({
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    } as never);
+
+    expect(result).toHaveProperty("errors");
+    expect(mockCreateSession).not.toHaveBeenCalled();
+  });
+
+  it("returns validation errors when priceId is empty", async () => {
+    const result = await purchaseAction({
+      priceId: "",
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    expect(result).toHaveProperty("errors");
+    expect(mockCreateSession).not.toHaveBeenCalled();
+  });
+
+  it("returns validation errors when priceId contains invalid characters", async () => {
+    // priceId must be min length 1; test with a non-string
+    const result = await purchaseAction({
+      // eslint-disable-next-line no-restricted-syntax -- Phase 2/3 follow-up: pre-existing test-hygiene violation
+      priceId: 12345 as unknown as string,
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    expect(result).toHaveProperty("errors");
+    expect(mockCreateSession).not.toHaveBeenCalled();
+  });
+
+  it("returns validation errors when quantity is not a positive integer", async () => {
+    const result = await purchaseAction({
+      priceId: "price_test",
+      quantity: 0,
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    expect(result).toHaveProperty("errors");
+    expect(mockCreateSession).not.toHaveBeenCalled();
+  });
+});
+
+describe("purchaseAction — parity shape with ailkPurchase", () => {
+  it("success shape matches ailkPurchase success shape: { url: string }", async () => {
+    mockCreateSession.mockResolvedValueOnce({
+      ok: true,
+      body: {
+        sessionId: "cs_test_parity",
+        url: "https://checkout.stripe.com/pay/cs_test_parity",
+      },
+    });
+
+    const result = await purchaseAction({
+      priceId: "price_parity",
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    expect(typeof (result as { url: string }).url).toBe("string");
+  });
+});

package/templates/apps/web/app/[locale]/dev/purchase/error.tsx

@@ -0,0 +1,25 @@
+"use client";
+// Per-segment error boundary for the /dev/purchase (checkout) route.
+// Does not make any claim about whether payment was processed.
+import type { ReactElement } from "react";
+
+import { ErrorFallback } from "../../../error-fallback";
+
+interface ErrorProps {
+  error: Error & { digest?: string };
+  reset: () => void;
+}
+
+export default function PurchaseError({
+  error,
+  reset,
+}: ErrorProps): ReactElement {
+  return (
+    <ErrorFallback
+      error={error}
+      reset={reset}
+      heading="Checkout couldn't complete"
+      body="Something interrupted your purchase attempt. Please try again to continue."
+    />
+  );
+}

package/templates/apps/web/app/[locale]/dev/purchase/page.tsx

@@ -0,0 +1,117 @@
+/* eslint-disable no-restricted-syntax -- i18n-allow: dev-only route, not in customer navigation (ADR 0019) */
+"use client";
+
+/**
+ * /dev/purchase — demo route for the purchaseAction Server Action.
+ *
+ * SD-3d: /dev/-prefixed routes are not in customer-visible navigation.
+ * This page exists to exercise the Server Action / MCP tool parity pair
+ * in a browser context during Phase 3 development.
+ */
+
+import { useState } from "react";
+
+import { purchaseAction } from "./purchase.actions";
+import type { PurchaseActionResult } from "./purchase.actions";
+
+export default function DevPurchasePage() {
+  const [priceId, setPriceId] = useState("price_test_123");
+  const [result, setResult] = useState<PurchaseActionResult | null>(null);
+  const [pending, setPending] = useState(false);
+
+  async function handleSubmit(e: React.FormEvent<HTMLFormElement>) {
+    e.preventDefault();
+    setPending(true);
+    setResult(null);
+    try {
+      const res = await purchaseAction({ priceId });
+      setResult(res);
+      if ("url" in res) {
+        window.location.href = res.url;
+      }
+    } finally {
+      setPending(false);
+    }
+  }
+
+  return (
+    <main style={{ padding: "2rem", maxWidth: 480 }}>
+      <h1>Dev: Purchase (Server Action smoke test)</h1>
+      <p style={{ fontSize: "0.875rem", color: "#666" }}>
+        /dev/ — not in customer navigation
+      </p>
+
+      <form
+        onSubmit={(e) => void handleSubmit(e)}
+        style={{
+          display: "flex",
+          flexDirection: "column",
+          gap: "1rem",
+          marginTop: "1.5rem",
+        }}
+      >
+        <label>
+          <span
+            style={{
+              display: "block",
+              marginBottom: "0.25rem",
+              fontWeight: 500,
+            }}
+          >
+            Price ID
+          </span>
+          <input
+            type="text"
+            value={priceId}
+            onChange={(e) => setPriceId(e.target.value)}
+            placeholder="price_test_..."
+            required
+            style={{
+              width: "100%",
+              padding: "0.5rem",
+              border: "1px solid #ccc",
+              borderRadius: 4,
+            }}
+          />
+        </label>
+
+        <button
+          type="submit"
+          disabled={pending}
+          style={{
+            padding: "0.5rem 1rem",
+            background: "#0070f3",
+            color: "#fff",
+            border: "none",
+            borderRadius: 4,
+            cursor: pending ? "not-allowed" : "pointer",
+          }}
+        >
+          {pending ? "Creating session…" : "Start checkout"}
+        </button>
+      </form>
+
+      {result && (
+        <div style={{ marginTop: "1.5rem" }}>
+          {"errors" in result ? (
+            <div>
+              <strong>Validation errors:</strong>
+              <ul>
+                {result.errors.map((e, i) => (
+                  <li key={i}>
+                    {e.path.join(".") || "input"}: {e.message}
+                  </li>
+                ))}
+              </ul>
+            </div>
+          ) : (
+            <div>
+              <strong>Checkout URL:</strong>{" "}
+              <a href={result.url}>{result.url}</a>
+            </div>
+          )}
+        </div>
+      )}
+    </main>
+  );
+}

package/templates/apps/web/app/[locale]/dev/purchase/purchase.actions.ts

@@ -0,0 +1,58 @@
+"use server";
+
+/**
+ * purchaseAction — Server Action paired with ailkPurchase MCP tool.
+ *
+ * Validates input with purchaseInputSchema (shared schema per ADR 0013),
+ * calls POST /api/checkout/sessions via @working-theory/api-client, and returns the
+ * Stripe hosted-checkout URL on success or a validation error object.
+ *
+ * Canonical filename: purchase.actions.ts (*.actions.ts per ADR 0013 / U0 spec
+ * parity-test regex `ACTION_FILE_RE = /\.actions\.ts$/`).
+ */
+
+import { checkout } from "@working-theory/api-client";
+import { purchaseInputSchema } from "@working-theory/validation";
+import type { PurchaseInput, PurchaseOutput } from "@working-theory/validation";
+
+export type PurchaseActionResult =
+  | PurchaseOutput
+  | { errors: { path: (string | number)[]; message: string }[] };
+
+/**
+ * Initiate a Stripe checkout session for the given price.
+ *
+ * On success: returns `{ url: string }` — redirect the user to this URL.
+ * On validation failure: returns `{ errors: ZodIssue[] }`.
+ * On API failure: throws (will surface as a Next.js server error boundary).
+ */
+export async function purchaseAction(
+  input: PurchaseInput,
+): Promise<PurchaseActionResult> {
+  const parsed = purchaseInputSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      errors: parsed.error.issues.map((issue) => ({
+        path: issue.path as (string | number)[],
+        message: issue.message,
+      })),
+    };
+  }
+
+  const { priceId, quantity, successUrl, cancelUrl } = parsed.data;
+
+  const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || "http://localhost:3000";
+
+  const result = await checkout.createSession({
+    productCode: priceId,
+    ...(quantity !== undefined && { quantity }),
+    successUrl: successUrl ?? `${baseUrl}/purchase/success`,
+    cancelUrl: cancelUrl ?? `${baseUrl}/purchase/cancel`,
+  });
+
+  if (!result.ok) {
+    throw new Error(`Checkout session creation failed (${result.status})`);
+  }
+
+  return { url: result.body.url };
+}

package/templates/apps/web/app/[locale]/docs/[[...slug]]/page.tsx

@@ -0,0 +1,118 @@
+/**
+ * /docs catch-all route. Renders placeholder docs from
+ * `apps/web/content/en/docs/` via the Fumadocs docsSource loader.
+ *
+ * Mirrors the blog route structure — same injectable-source pattern for
+ * testability. Index renders a list of all docs pages; slug routes render
+ * the individual doc.
+ *
+ * Issue #1459: per-app content directory divergence (2026-05-25).
+ */
+import type { Metadata } from "next";
+import { notFound } from "next/navigation";
+import { getTranslations } from "next-intl/server";
+import type { ReactElement } from "react";
+
+import { docsSource as defaultDocsSource } from "../../../../lib/source";
+
+/**
+ * Frontmatter contract — must match `source.config.ts` `docs.schema`.
+ */
+interface DocsFrontmatter {
+  title: string;
+  description: string;
+}
+
+/**
+ * Minimal docs-source interface covering the subset consumed by this route.
+ * Tests inject a stub without mocking lib/source at the module level.
+ */
+interface DocsSource {
+  getPages: () => Array<{ url: string; data: unknown }>;
+  getPage: (slug: string[]) => { data: unknown } | undefined;
+}
+
+interface DocsRouteProps {
+  params: Promise<{ locale: string; slug?: string[] }>;
+  /**
+   * Docs source override for testing. Defaults to the real Fumadocs docsSource.
+   */
+  docsSource?: DocsSource;
+}
+
+export async function generateMetadata(
+  props: DocsRouteProps,
+): Promise<Metadata> {
+  const { slug } = await props.params;
+  const source = props.docsSource ?? defaultDocsSource;
+
+  if (slug && slug.length > 0) {
+    const page = source.getPage(slug);
+    if (page) {
+      const data = page.data as unknown as DocsFrontmatter;
+      return {
+        title: data.title,
+        description: data.description,
+      };
+    }
+  }
+
+  return {
+    title: "Docs",
+    description: "Documentation for AI Launch Kit.",
+  };
+}
+
+export default async function DocsRoute(
+  props: DocsRouteProps,
+): Promise<ReactElement> {
+  const { slug } = await props.params;
+  const t = await getTranslations("docs");
+  const source = props.docsSource ?? defaultDocsSource;
+
+  if (slug && slug.length > 0) {
+    const page = source.getPage(slug);
+    if (!page) notFound();
+
+    const data = page.data as unknown as DocsFrontmatter;
+
+    return (
+      <main>
+        <h1>{data.title}</h1>
+        <p>{data.description}</p>
+      </main>
+    );
+  }
+
+  const pages = source.getPages();
+
+  if (pages.length === 0) {
+    return (
+      <main>
+        <h1>{t("heading")}</h1>
+        <p>
+          {t("emptyState")} <code>{"apps/web/content/en/docs/"}</code>{" "}
+          {t("emptyStateTrailing")}
+        </p>
+      </main>
+    );
+  }
+
+  return (
+    <main>
+      <h1>{t("heading")}</h1>
+      <ul>
+        {pages.map((page) => {
+          const data = page.data as unknown as DocsFrontmatter;
+          return (
+            <li key={page.url}>
+              <a href={page.url}>{data.title}</a>
+              {" \u2014 "}
+              {data.description}
+            </li>
+          );
+        })}
+      </ul>
+    </main>
+  );
+}

package/templates/apps/web/app/[locale]/downloads/__tests__/page-renderer-migration.test.tsx

@@ -0,0 +1,72 @@
+/**
+ * HTML snapshot regression tests for the downloads route →
+ * @working-theory/page-renderer renderPage({ bodyMode: "mdx-body" }) migration.
+ *
+ * Two-commit strategy:
+ *   Commit 1: snapshots captured against pre-migration route (baseline).
+ *   Commit 2: route migrated; same snapshots verify diff=0.
+ *
+ * Routes covered:
+ *   - downloads/page.tsx  (empty + populated — 2 snapshots)
+ *
+ * Failure = snapshot diff > 0 bytes. DO NOT regenerate snapshots to pass.
+ */
+import React from "react";
+import { render } from "@testing-library/react";
+
+// ── next-mdx-remote/rsc mock ──────────────────────────────────────────────────
+jest.mock("next-mdx-remote/rsc", () => ({
+  MDXRemote: ({ source }: { source: string }): React.ReactElement =>
+    React.createElement("div", { "data-testid": "mdx-rendered" }, source),
+}));
+
+// ── @working-theory/ui mock ─────────────────────────────────────────────────────────────
+jest.mock("@working-theory/ui", () => ({
+  SectionRenderer: ({ sections }: { sections: unknown[] }) =>
+    React.createElement("div", {
+      "data-testid": "section-renderer",
+      "data-section-count": String(sections.length),
+    }),
+}));
+
+import DownloadsPage from "../page";
+
+const getMdxSourceEmpty = jest.fn().mockResolvedValue(null);
+
+// ── DownloadsPage ─────────────────────────────────────────────────────────────
+
+describe("DownloadsPage — snapshot regression", () => {
+  it("empty state renders deterministic HTML", async () => {
+    const element = await DownloadsPage({
+      params: Promise.resolve({ locale: "en" }),
+      getMdxSource: getMdxSourceEmpty,
+    });
+    const { container } = render(element);
+    expect(container.innerHTML).toMatchInlineSnapshot(
+      `"<main><h1>Downloads</h1><p data-testid="section-empty-state">Downloads listing coming soon.</p></main>"`,
+    );
+  });
+
+  it("populated state renders deterministic HTML", async () => {
+    const getMdxSourcePopulated = jest.fn().mockResolvedValue({
+      frontmatter: {
+        type: "DownloadsList",
+        slug: "downloads",
+        title: "Downloads",
+        description: "Downloadable assets and templates.",
+      },
+      body: "# Downloads\n\nBody.",
+    });
+
+    const element = await DownloadsPage({
+      params: Promise.resolve({ locale: "en" }),
+      getMdxSource: getMdxSourcePopulated,
+    });
+    const { container } = render(element);
+    expect(container.innerHTML).toMatchInlineSnapshot(`
+     "<script type="application/ld+json" data-testid="json-ld">{"@context":"https://schema.org","@type":"CollectionPage","inLanguage":"en","name":"Downloads","description":"Downloadable assets and templates.","mainEntity":{"@type":"ItemList","itemListElement":[{"@type":"DigitalDocument"}]}}</script><main><h1>Downloads</h1><p data-testid="downloads-description">Downloadable assets and templates.</p><div data-testid="markdown-view-toggle" class="ailk-markdown-view-toggle"><div class="flex justify-end mb-3"><div role="radiogroup" aria-label="Page view" data-testid="markdown-view-toggle" class="inline-flex items-center gap-0.5 rounded-lg p-1 bg-(--color-surface-secondary)"><button class="inline-flex items-center justify-center gap-2 font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-(--color-accent) focus-visible:ring-offset-1 disabled:cursor-not-allowed disabled:opacity-50 [&amp;>svg]:shrink-0 text-(--color-fg) hover:bg-(--color-surface-secondary) active:bg-gray-200 rounded-control px-control-x h-(--control-height-thin) text-caption leading-none rounded-md px-3 text-body-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-(--color-accent) focus-visible:ring-offset-1 min-w-(--control-height-thin) bg-(--color-bg) text-(--color-fg) shadow-sm" type="button" role="radio" aria-checked="true" aria-label="Rendered" tabindex="0" data-testid="markdown-view-toggle-rendered">Rendered</button><button class="inline-flex items-center justify-center gap-2 font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-(--color-accent) focus-visible:ring-offset-1 disabled:cursor-not-allowed disabled:opacity-50 [&amp;>svg]:shrink-0 text-(--color-fg) hover:bg-(--color-surface-secondary) active:bg-gray-200 rounded-control px-control-x h-(--control-height-thin) text-caption leading-none rounded-md px-3 text-body-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-(--color-accent) focus-visible:ring-offset-1 min-w-(--control-height-thin) text-(--color-text-muted) hover:text-(--color-fg)" type="button" role="radio" aria-checked="false" aria-label="Markdown" tabindex="-1" data-testid="markdown-view-toggle-markdown">Markdown</button></div></div><div role="status" aria-live="polite" aria-atomic="true" class="sr-only" data-testid="markdown-view-toggle-status">Showing Rendered view</div><div data-testid="markdown-view-rendered"><article data-testid="mdx-body"><div data-testid="mdx-rendered"># Downloads
+
+     Body.</div></article></div></div></main>"
+    `);
+  });
+});

package/templates/apps/web/app/[locale]/downloads/page.tsx

@@ -0,0 +1,25 @@
+// Downloads list page. Reads DownloadsList MDX via renderPage and emits
+// a JSON-LD CollectionPage via the dispatcher. List-only — no detail route.
+import type { getMdxSource as defaultGetMdxSource } from "@working-theory/page-renderer";
+import { renderPage } from "@working-theory/page-renderer";
+import type { ReactElement } from "react";
+
+interface Props {
+  params: Promise<{ locale: string }>;
+  getMdxSource?: typeof defaultGetMdxSource;
+}
+
+export default async function Page({
+  params,
+  getMdxSource,
+}: Props): Promise<ReactElement> {
+  const { locale } = await params;
+  return renderPage({
+    type: "DownloadsList",
+    slug: "downloads",
+    locale,
+    translationsNamespace: "downloads",
+    bodyMode: "mdx-body",
+    ...(getMdxSource !== undefined && { getMdxSource }),
+  });
+}

package/templates/apps/web/app/[locale]/events/[slug]/page.tsx

@@ -0,0 +1,47 @@
+// Event detail page. Reads the Event MDX for the given slug, renders via
+// renderPage, and emits a JSON-LD <script>. Unknown slugs trigger 404.
+import {
+  renderPage,
+  getMdxSource as defaultGetMdxSource,
+  getMdxSlugs,
+} from "@working-theory/page-renderer";
+import { notFound } from "next/navigation";
+import type { ReactElement } from "react";
+
+interface Props {
+  params: Promise<{ locale: string; slug: string }>;
+  getMdxSource?: typeof defaultGetMdxSource;
+}
+
+export async function generateStaticParams({
+  params,
+}: {
+  params: { locale: string };
+}): Promise<{ slug: string }[]> {
+  const slugs = await getMdxSlugs("Event", params.locale);
+  return slugs.map((slug) => ({ slug }));
+}
+
+export default async function Page({
+  params,
+  getMdxSource = defaultGetMdxSource,
+}: Props): Promise<ReactElement> {
+  const { locale, slug } = await params;
+
+  // Pre-check: detail pages call notFound() rather than rendering an empty-state.
+  // Inject the resolved source so renderPage does not call getMdxSource a second time.
+  const source = await getMdxSource("Event", slug, locale);
+
+  if (!source) {
+    notFound();
+  }
+
+  return renderPage({
+    type: "Event",
+    slug,
+    locale,
+    translationsNamespace: "events",
+    bodyMode: "mdx-body",
+    getMdxSource: async () => source,
+  });
+}