create-ailk 0.1.0

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

@@ -0,0 +1,161 @@
+/**
+ * Tests for the subscribe_newsletter MCP tool handler.
+ *
+ * Acceptance criteria verified here:
+ * 1. Malformed input → { ok: false, error: { kind: 'invalid_input', issues } }, api-client never called
+ * 2. Happy path → forwards to apiClient.leads.subscribe, returns { ok: true, id, persisted }
+ * 3. API 400 → { ok: false, error: { kind: 'api_error', status: 400 } }
+ * 4. API 503 → { ok: false, error: { kind: 'api_error', status: 503 } }
+ * 5. API 429 → { ok: false, error: { kind: 'api_error', status: 429 } }
+ */
+
+import { ailkSubscribeNewsletter } from "../src/tools/subscribe_newsletter.js";
+
+jest.mock("@working-theory/api-client", () => ({
+  apiClient: {
+    leads: {
+      subscribe: jest.fn(),
+    },
+  },
+}));
+
+ 
+const { apiClient } = require("@working-theory/api-client") as {
+  apiClient: { leads: { subscribe: jest.Mock } };
+};
+
+const VALID_INPUT = {
+  email: "jane@example.com",
+};
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("ailkSubscribeNewsletter — input validation", () => {
+  it("rejects malformed input (invalid email) without calling api-client", async () => {
+    const result = await ailkSubscribeNewsletter({ email: "not-an-email" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.kind).toBe("invalid_input");
+      if (result.error.kind === "invalid_input") {
+        expect(Array.isArray(result.error.issues)).toBe(true);
+        expect(result.error.issues.length).toBeGreaterThan(0);
+      }
+    }
+    expect(apiClient.leads.subscribe).not.toHaveBeenCalled();
+  });
+});
+
+describe("ailkSubscribeNewsletter — happy path", () => {
+  it("forwards canonical body to api-client and returns ok:true with id and persisted", async () => {
+    apiClient.leads.subscribe.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "sub_xyz789", persisted: "db" },
+    });
+
+    const result = await ailkSubscribeNewsletter(VALID_INPUT);
+
+    expect(apiClient.leads.subscribe).toHaveBeenCalledWith({
+      siteId: "default",
+      email: "jane@example.com",
+      source: "mcp",
+    });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.id).toBe("sub_xyz789");
+      expect(result.persisted).toBe("db");
+    }
+  });
+});
+
+describe("ailkSubscribeNewsletter — API error mapping", () => {
+  it("maps API 400 to { ok: false, error: { kind: 'api_error', status: 400 } }", async () => {
+    apiClient.leads.subscribe.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      body: { error: "bad_request" },
+    });
+
+    const result = await ailkSubscribeNewsletter(VALID_INPUT);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.kind).toBe("api_error");
+      if (result.error.kind === "api_error") {
+        expect(result.error.status).toBe(400);
+      }
+    }
+  });
+
+  it("maps API 503 to { ok: false, error: { kind: 'api_error', status: 503 } }", async () => {
+    apiClient.leads.subscribe.mockResolvedValueOnce({
+      ok: false,
+      status: 503,
+      body: { error: "service_unavailable" },
+    });
+
+    const result = await ailkSubscribeNewsletter(VALID_INPUT);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.kind).toBe("api_error");
+      if (result.error.kind === "api_error") {
+        expect(result.error.status).toBe(503);
+      }
+    }
+  });
+
+  it("maps API 429 to { ok: false, error: { kind: 'api_error', status: 429 } }", async () => {
+    apiClient.leads.subscribe.mockResolvedValueOnce({
+      ok: false,
+      status: 429,
+      body: { error: "rate_limited" },
+    });
+
+    const result = await ailkSubscribeNewsletter(VALID_INPUT);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.kind).toBe("api_error");
+      if (result.error.kind === "api_error") {
+        expect(result.error.status).toBe(429);
+      }
+    }
+  });
+});
+
+describe("ailkSubscribeNewsletter — siteId default", () => {
+  it("uses siteId 'default' when AILK_SITE_ID is unset", async () => {
+    delete process.env.AILK_SITE_ID;
+    apiClient.leads.subscribe.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "sub_default", persisted: "db" },
+    });
+
+    await ailkSubscribeNewsletter(VALID_INPUT);
+
+    const call = apiClient.leads.subscribe.mock.calls[0][0] as { siteId: string };
+    expect(call.siteId).toBe("default");
+  });
+});
+
+describe("ailkSubscribeNewsletter — siteId override", () => {
+  afterEach(() => {
+    delete process.env.AILK_SITE_ID;
+  });
+
+  it("uses AILK_SITE_ID env var when set", async () => {
+    process.env.AILK_SITE_ID = "site-abc";
+    apiClient.leads.subscribe.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "sub_override", persisted: "db" },
+    });
+
+    await ailkSubscribeNewsletter(VALID_INPUT);
+
+    const call = apiClient.leads.subscribe.mock.calls[0][0] as { siteId: string };
+    expect(call.siteId).toBe("site-abc");
+  });
+});

package/templates/apps/mcp/__tests__/tools/purchase.test.ts

@@ -0,0 +1,227 @@
+/**
+ * Tests for the ailkPurchase MCP tool (Phase 3 U2: live implementation).
+ *
+ * Acceptance criteria verified here:
+ * - purchaseInputSchema validates correct inputs
+ * - purchaseInputSchema rejects invalid inputs
+ * - purchaseOutputSchema validates { url: string } live shape
+ * - ailkPurchase handler calls POST /v1/checkout/sessions
+ * - ailkPurchase returns { url: string } on success
+ * - ailkPurchase returns Zod errors on invalid input
+ * - No Stripe SDK import in apps/mcp (architectural guard)
+ * - Parity: response shape matches purchaseAction Server Action shape
+ */
+
+import { ailkPurchase } from "../../src/tools/purchase.js";
+import {
+  purchaseInputSchema as PurchaseInputSchema,
+  purchaseOutputSchema as PurchaseOutputSchema,
+} from "@working-theory/validation";
+
+// ── fetch mock ────────────────────────────────────────────────────────────────
+
+const mockFetch = jest.fn();
+global.fetch = mockFetch;
+
+afterEach(() => {
+  jest.clearAllMocks();
+});
+
+// ── Input schema ──────────────────────────────────────────────────────────────
+
+describe("PurchaseInputSchema", () => {
+  it("accepts valid input with priceId and quantity", () => {
+    const result = PurchaseInputSchema.safeParse({
+      priceId: "price_test_123",
+      quantity: 1,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts valid input with priceId only (quantity defaults)", () => {
+    const result = PurchaseInputSchema.safeParse({
+      priceId: "price_test_abc",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts valid input with successUrl and cancelUrl", () => {
+    const result = PurchaseInputSchema.safeParse({
+      priceId: "price_test_123",
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects input missing priceId", () => {
+    const result = PurchaseInputSchema.safeParse({ quantity: 1 });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects input with empty priceId", () => {
+    const result = PurchaseInputSchema.safeParse({ priceId: "" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects input with non-integer quantity", () => {
+    const result = PurchaseInputSchema.safeParse({
+      priceId: "price_x",
+      quantity: 1.5,
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects input with quantity less than 1", () => {
+    const result = PurchaseInputSchema.safeParse({
+      priceId: "price_x",
+      quantity: 0,
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+// ── Output schema (live shape) ────────────────────────────────────────────────
+
+describe("PurchaseOutputSchema", () => {
+  it("accepts the live success shape { url: string }", () => {
+    const result = PurchaseOutputSchema.safeParse({
+      url: "https://checkout.stripe.com/pay/cs_test_abc123",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects output missing url", () => {
+    const result = PurchaseOutputSchema.safeParse({});
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects output where url is not a string", () => {
+    const result = PurchaseOutputSchema.safeParse({ url: 42 });
+    expect(result.success).toBe(false);
+  });
+});
+
+// ── ailkPurchase handler ──────────────────────────────────────────────────────
+
+describe("ailkPurchase — valid input", () => {
+  it("calls POST /v1/checkout/sessions with mapped payload", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 201,
+      json: () =>
+        Promise.resolve({
+          sessionId: "cs_test_abc123",
+          url: "https://checkout.stripe.com/pay/cs_test_abc123",
+        }),
+    });
+
+    await ailkPurchase({
+      priceId: "price_test_123",
+      quantity: 1,
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    const [url, opts] = mockFetch.mock.calls[0] as [string, RequestInit];
+    expect(url).toMatch(/\/v1\/checkout\/sessions$/);
+    expect(opts.method).toBe("POST");
+    const body = JSON.parse(opts.body as string) as Record<string, unknown>;
+    expect(body.productCode).toBe("price_test_123");
+    expect(body.quantity).toBe(1);
+  });
+
+  it("returns { url } on success", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 201,
+      json: () =>
+        Promise.resolve({
+          sessionId: "cs_test_xyz",
+          url: "https://checkout.stripe.com/pay/cs_test_xyz",
+        }),
+    });
+
+    const output = await ailkPurchase({
+      priceId: "price_test_xyz",
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    expect(output).toEqual({
+      url: "https://checkout.stripe.com/pay/cs_test_xyz",
+    });
+  });
+
+  it("output validates against PurchaseOutputSchema", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 201,
+      json: () =>
+        Promise.resolve({
+          sessionId: "cs_test_valid",
+          url: "https://checkout.stripe.com/pay/cs_test_valid",
+        }),
+    });
+
+    const output = await ailkPurchase({ priceId: "price_test_valid" });
+    const result = PurchaseOutputSchema.safeParse(output);
+    expect(result.success).toBe(true);
+  });
+});
+
+describe("ailkPurchase — invalid input (Zod errors)", () => {
+  it("throws ZodError for missing priceId before any fetch", async () => {
+    await expect(
+      ailkPurchase({ quantity: 1 } as never),
+    ).rejects.toThrow();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it("throws ZodError for empty priceId before any fetch", async () => {
+    await expect(
+      ailkPurchase({ priceId: "" }),
+    ).rejects.toThrow();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+});
+
+describe("ailkPurchase — parity shape with purchaseAction", () => {
+  it("success shape is { url: string } matching Server Action shape", async () => {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      status: 201,
+      json: () =>
+        Promise.resolve({
+          sessionId: "cs_test_parity",
+          url: "https://checkout.stripe.com/pay/cs_test_parity",
+        }),
+    });
+
+    const output = await ailkPurchase({
+      priceId: "price_parity",
+      successUrl: "https://example.com/success",
+      cancelUrl: "https://example.com/cancel",
+    });
+
+    // Shape must match purchaseAction's success shape
+    expect(output).toHaveProperty("url");
+    expect(typeof (output as { url: string }).url).toBe("string");
+  });
+});
+
+// ── Architectural guard ───────────────────────────────────────────────────────
+
+describe("architectural guard — no Stripe import", () => {
+  it("apps/mcp/src/tools/purchase.ts does not import stripe", async () => {
+    const { readFileSync } = await import("node:fs");
+    const { resolve } = await import("node:path");
+    const src = readFileSync(
+      resolve(__dirname, "../../src/tools/purchase.ts"),
+      "utf-8",
+    );
+    expect(src).not.toMatch(/import.*['"]stripe['"]/);
+    expect(src).not.toMatch(/require\s*\(\s*['"]stripe['"]/);
+  });
+});

package/templates/apps/mcp/__tests__/tools/scaffold.test.ts

@@ -0,0 +1,237 @@
+/**
+ * Tests for the ailkScaffold MCP tool handler.
+ *
+ * Acceptance criteria verified here:
+ * - scaffoldInputSchema validates correct inputs
+ * - scaffoldInputSchema rejects invalid inputs (empty projectName, missing targetDir)
+ * - ailkScaffold scaffolds into a tmp dir: package.json + ≥1 file created
+ * - ailkScaffold fails cleanly when targetDir is non-empty (rejects with Error)
+ * - Output validates against scaffoldOutputSchema
+ * - No direct create-ailk import in apps/mcp (architectural guard)
+ *
+ * Hermetic: uses os.tmpdir() + unique subdir. No network calls.
+ * Integration tests pass CLI_PATH explicitly to ailkScaffold (second arg)
+ * so they don't depend on process.cwd() being the repo root in Jest.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+import { scaffoldInputSchema, scaffoldOutputSchema } from "@working-theory/validation";
+
+import { ailkScaffold } from "../../src/tools/scaffold.js";
+
+// ── Input schema tests ────────────────────────────────────────────────────────
+
+describe("scaffoldInputSchema", () => {
+  it("accepts valid input with targetDir and projectName", () => {
+    const result = scaffoldInputSchema.safeParse({
+      targetDir: "/tmp/my-site",
+      projectName: "my-site",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts valid input with optional preset", () => {
+    const result = scaffoldInputSchema.safeParse({
+      targetDir: "/tmp/my-site",
+      projectName: "my-site",
+      preset: "default",
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects input missing targetDir", () => {
+    const result = scaffoldInputSchema.safeParse({
+      projectName: "my-site",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects input with empty projectName", () => {
+    const result = scaffoldInputSchema.safeParse({
+      targetDir: "/tmp/my-site",
+      projectName: "",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects input missing projectName", () => {
+    const result = scaffoldInputSchema.safeParse({
+      targetDir: "/tmp/my-site",
+    });
+    expect(result.success).toBe(false);
+  });
+});
+
+// ── Output schema tests ───────────────────────────────────────────────────────
+
+describe("scaffoldOutputSchema", () => {
+  it("accepts a valid success output", () => {
+    const result = scaffoldOutputSchema.safeParse({
+      targetDir: "/tmp/my-site",
+      filesCreated: 5,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts zero filesCreated (empty template edge case)", () => {
+    const result = scaffoldOutputSchema.safeParse({
+      targetDir: "/tmp/my-site",
+      filesCreated: 0,
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects output missing targetDir", () => {
+    const result = scaffoldOutputSchema.safeParse({ filesCreated: 5 });
+    expect(result.success).toBe(false);
+  });
+});
+
+// ── Handler integration tests ─────────────────────────────────────────────────
+
+// Resolve CLI_PATH relative to the repo root using __dirname traversal.
+// __tests__/tools → __tests__ → apps/mcp → apps → repo root
+const REPO_ROOT = resolve(__dirname, "../../../..");
+const CLI_PATH = join(REPO_ROOT, "packages/create-ailk/dist/cli.js");
+
+describe("ailkScaffold handler", () => {
+  let scratch: string;
+
+  beforeAll(() => {
+    if (!existsSync(CLI_PATH)) {
+      console.warn(
+        `[scaffold.test] create-ailk CLI not built: ${CLI_PATH} missing. ` +
+          "Run `pnpm --filter create-ailk build` first.",
+      );
+    }
+  });
+
+  beforeEach(() => {
+    scratch = mkdtempSync(join(tmpdir(), "ailk-mcp-scaffold-"));
+  });
+
+  afterEach(() => {
+    rmSync(scratch, { recursive: true, force: true });
+  });
+
+  it("scaffolds at least one file into a fresh tmp dir and reports targetDir", async () => {
+    if (!existsSync(CLI_PATH)) {
+      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      return;
+    }
+    const target = join(scratch, "my-site");
+    const output = await ailkScaffold(
+      { targetDir: target, projectName: "my-site" },
+      CLI_PATH,
+    );
+    expect(output.targetDir).toBe(target);
+    expect(output.filesCreated).toBeGreaterThan(0);
+  });
+
+  it("scaffolds package.json when full templates are built (build-templates required)", async () => {
+    if (!existsSync(CLI_PATH)) {
+      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      return;
+    }
+    const TEMPLATES_DIR = join(REPO_ROOT, "packages/create-ailk/templates");
+    const PKG_JSON_IN_TEMPLATES = join(TEMPLATES_DIR, "package.json");
+    if (!existsSync(PKG_JSON_IN_TEMPLATES)) {
+      console.warn(
+        "[scaffold.test] skipping package.json assertion — run `pnpm --filter create-ailk run build-templates` first",
+      );
+      return;
+    }
+    const target = join(scratch, "my-site");
+    await ailkScaffold({ targetDir: target, projectName: "my-site" }, CLI_PATH);
+    expect(existsSync(join(target, "package.json"))).toBe(true);
+  });
+
+  it("scaffolds app dir when full templates are built (build-templates required)", async () => {
+    if (!existsSync(CLI_PATH)) {
+      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      return;
+    }
+    const TEMPLATES_DIR = join(REPO_ROOT, "packages/create-ailk/templates");
+    const PKG_JSON_IN_TEMPLATES = join(TEMPLATES_DIR, "package.json");
+    if (!existsSync(PKG_JSON_IN_TEMPLATES)) {
+      console.warn(
+        "[scaffold.test] skipping app dir assertion — run `pnpm --filter create-ailk run build-templates` first",
+      );
+      return;
+    }
+    const target = join(scratch, "my-site");
+    await ailkScaffold({ targetDir: target, projectName: "my-site" }, CLI_PATH);
+    // The template produces apps/web/app/ from the monorepo template snapshot.
+    const hasApp =
+      existsSync(join(target, "app")) ||
+      existsSync(join(target, "apps", "web", "app"));
+    expect(hasApp).toBe(true);
+  });
+
+  it("returns at least one file (schema-typed page seed or README.md)", async () => {
+    if (!existsSync(CLI_PATH)) {
+      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      return;
+    }
+    const target = join(scratch, "my-site");
+    await ailkScaffold({ targetDir: target, projectName: "my-site" }, CLI_PATH);
+    // At minimum README.md is always emitted by the template.
+    expect(existsSync(join(target, "README.md"))).toBe(true);
+  });
+
+  it("returns output conforming to scaffoldOutputSchema", async () => {
+    if (!existsSync(CLI_PATH)) {
+      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      return;
+    }
+    const target = join(scratch, "my-site");
+    const output = await ailkScaffold(
+      { targetDir: target, projectName: "my-site" },
+      CLI_PATH,
+    );
+    const result = scaffoldOutputSchema.safeParse(output);
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects with a clear error when targetDir is non-empty", async () => {
+    if (!existsSync(CLI_PATH)) {
+      console.warn("[scaffold.test] skipping integration test — CLI not built");
+      return;
+    }
+    const target = join(scratch, "populated");
+    mkdirSync(target);
+    writeFileSync(join(target, "existing.txt"), "data");
+
+    // The create-ailk CLI exits non-zero with a ValidationError message when
+    // the target exists and is non-empty. The MCP handler rejects with a
+    // descriptive Error whose message matches the CLI stderr output.
+    await expect(
+      ailkScaffold({ targetDir: target, projectName: "populated" }, CLI_PATH),
+    ).rejects.toThrow(/non-empty|exists/i);
+  });
+});
+
+// ── Architectural guard ───────────────────────────────────────────────────────
+
+describe("architectural guard — no create-ailk direct import", () => {
+  it("apps/mcp/src/tools/scaffold.ts does not import create-ailk directly", async () => {
+    const { readFileSync } = await import("node:fs");
+    const { resolve: res } = await import("node:path");
+    const src = readFileSync(
+      res(__dirname, "../../src/tools/scaffold.ts"),
+      "utf-8",
+    );
+    // Must not have a static import of create-ailk or its dist
+    expect(src).not.toMatch(/from ['"]create-ailk['"]/);
+    expect(src).not.toMatch(/require\s*\(\s*['"]create-ailk['"]/);
+  });
+});