create-ailk 0.24.0 → 0.25.1

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

@@ -1,160 +0,0 @@
-/**
- * Tests for the request_callback MCP tool handler.
- *
- * The tool takes the body `POST /v1/leads/callback` takes — `{ name, phone,
- * preferredTime?, payload? }` — and returns the route's 201 body (#7173
- * AC-11 — the tool adopted the API). Verified here:
- * 1. Malformed input → { ok: false, error: { kind: 'invalid_input', issues } }, api-client never called
- * 2. Happy path → posts exactly the parsed body to apiClient.leads.callback —
- *    no `siteId`, whatever AILK_SITE_ID says, no stamped `payload: {}` — and
- *    returns the route's body unchanged, `email` included
- * 3. API 400 / 503 / 429 → { ok: false, error: { kind: 'api_error', status } }
- * 4. #8073 — forwards the trusted caller address + AILK_VISITOR_FORWARD_KEY
- *    as the two visitor-forwarding headers only when both are present
- */
-
-import { ailkRequestCallback } from "../src/tools/request_callback.js";
-import { trustedCallerAddress } from "../src/request-context.js";
-
-// Everything but `apiClient.leads.callback` stays the ACTUAL
-// implementation — in particular `visitorForwardHeaders`, which
-// `request-context.ts` (imported above, for `trustedCallerAddress`) reads
-// for real.
-jest.mock("@working-theory/api-client", () => {
-  const actual = jest.requireActual("@working-theory/api-client");
-  return {
-    ...actual,
-    apiClient: {
-      ...actual.apiClient,
-      leads: { ...actual.apiClient.leads, callback: jest.fn() },
-    },
-  };
-});
-
-
-const { apiClient } = require("@working-theory/api-client") as {
-  apiClient: { leads: { callback: jest.Mock } };
-};
-
-/** The route body, as an agent sends it — the two required fields alone. */
-const VALID_INPUT = { name: "Jane Smith", phone: "+15555550100" };
-
-/** The route's 201 body, as the api-client hands it back. */
-const WIRE = {
-  id: "fallback-1700000000000-cb1",
-  persisted: "file",
-  email: { ok: false, error: "provider refused" },
-};
-
-beforeEach(() => {
-  jest.clearAllMocks();
-  delete process.env.AILK_SITE_ID;
-});
-
-describe("ailkRequestCallback — input validation", () => {
-  it.each([
-    ["missing required fields", {}],
-    ["a phone under the route's bound", { name: "Jane", phone: "12" }],
-  ])("rejects %s without calling api-client", async (_label, input) => {
-    const result = await ailkRequestCallback(input as never);
-
-    expect(result).toMatchObject({ ok: false, error: { kind: "invalid_input" } });
-    if (!result.ok && result.error.kind === "invalid_input") {
-      expect(result.error.issues.length).toBeGreaterThan(0);
-    }
-    expect(apiClient.leads.callback).not.toHaveBeenCalled();
-  });
-});
-
-describe("ailkRequestCallback — happy path", () => {
-  it("posts exactly the parsed body — no stamped payload — and returns the route's body unchanged, email included", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({ ok: true, body: WIRE });
-
-    const result = await ailkRequestCallback(VALID_INPUT);
-
-    expect(apiClient.leads.callback).toHaveBeenCalledWith(VALID_INPUT);
-    expect(result).toEqual(WIRE);
-  });
-
-  it("passes preferredTime and payload through as sent", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({ ok: true, body: WIRE });
-    const full = {
-      ...VALID_INPUT,
-      preferredTime: "Tuesday afternoon",
-      payload: { notes: "Roof estimate" },
-    };
-
-    await ailkRequestCallback(full);
-
-    expect(apiClient.leads.callback).toHaveBeenCalledWith(full);
-  });
-
-  it("never sends a siteId, whatever AILK_SITE_ID says, and strips one the agent sent", async () => {
-    process.env.AILK_SITE_ID = "site-abc";
-    apiClient.leads.callback.mockResolvedValueOnce({ ok: true, body: WIRE });
-
-    await ailkRequestCallback({ ...VALID_INPUT, siteId: "site-xyz" } as never);
-
-    expect(apiClient.leads.callback.mock.calls[0][0]).toEqual(VALID_INPUT);
-  });
-});
-
-describe("ailkRequestCallback — API error mapping", () => {
-  it.each([400, 503, 429])(
-    "maps API %i to { ok: false, error: { kind: 'api_error', status } }",
-    async (status) => {
-      apiClient.leads.callback.mockResolvedValueOnce({
-        ok: false,
-        status,
-        body: { error: "refused" },
-      });
-
-      const result = await ailkRequestCallback(VALID_INPUT);
-
-      expect(result).toEqual({ ok: false, error: { kind: "api_error", status } });
-    },
-  );
-});
-
-describe("ailkRequestCallback — visitor-forwarding headers (#8073)", () => {
-  afterEach(() => {
-    delete process.env.AILK_VISITOR_FORWARD_KEY;
-  });
-
-  it("calls api-client with exactly one argument when there is no trusted address", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({ ok: true, body: WIRE });
-    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
-
-    await ailkRequestCallback(VALID_INPUT);
-
-    expect(apiClient.leads.callback.mock.calls[0]).toHaveLength(1);
-  });
-
-  it("forwards the trusted address and the forward key as the two visitor headers", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({ ok: true, body: WIRE });
-    process.env.AILK_VISITOR_FORWARD_KEY = "spoke-key";
-
-    await trustedCallerAddress.run("203.0.113.9", () =>
-      ailkRequestCallback(VALID_INPUT),
-    );
-
-    const init = apiClient.leads.callback.mock.calls[0][1] as
-      | { headers?: Record<string, string> }
-      | undefined;
-    expect(init?.headers).toEqual({
-      "x-ailk-visitor-ip": "203.0.113.9",
-      "x-ailk-visitor-forward-key": "spoke-key",
-    });
-  });
-
-  it("sends no headers when there is a trusted address but no forward key", async () => {
-    apiClient.leads.callback.mockResolvedValueOnce({ ok: true, body: WIRE });
-    delete process.env.AILK_VISITOR_FORWARD_KEY;
-
-    await trustedCallerAddress.run("203.0.113.9", () =>
-      ailkRequestCallback(VALID_INPUT),
-    );
-
-    expect(apiClient.leads.callback.mock.calls[0]).toHaveLength(1);
-  });
-});

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

@@ -1,271 +0,0 @@
-/**
- * Tests for the search_content MCP tool handler.
- *
- * Acceptance criteria verified here:
- * - contentSearchQuerySchema validates correct inputs (q required, type + limit optional)
- * - contentSearchQuerySchema rejects q longer than 200 chars
- * - contentSearchQuerySchema rejects limit > 50
- * - contentSearchQuerySchema rejects empty q
- * - ailkSearchContent happy path returns the route's ItemList with items of the correct shape
- * - ailkSearchContent returns an empty ItemList for a query with no matches
- * - Malformed input causes Zod rejection
- * - #5831: contentSearchQuerySchema accepts a registry category slug and
- *   rejects one outside the registry; the handler forwards it to the adapter
- *
- * #7167 (the operator's decision of 2026-10-19): the tool adopted its route's
- * arguments (`q`, not `query`) and result (the `ItemList`, not `{ results }`),
- * so the cases below read the new names.
- */
-
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-
-import {
-  ailkSearchContent,
-  contentSearchQuerySchema,
-  contentSearchResultSchema,
-} from "../src/tools/search_content.js";
-
-const REPO_ROOT = resolve(__dirname, "../../..");
-const CONTENT_ROOT = `${REPO_ROOT}/content`;
-
-describe("contentSearchQuerySchema", () => {
-  it("accepts a valid q", () => {
-    const result = contentSearchQuerySchema.safeParse({ q: "hello" });
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts q with optional type filter", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "hello",
-      type: "HomePage",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts q with optional limit", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "hello",
-      limit: 10,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects an empty q", () => {
-    const result = contentSearchQuerySchema.safeParse({ q: "" });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects a q longer than 200 chars", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "a".repeat(201),
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("accepts a q exactly 200 chars", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "a".repeat(200),
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects limit of 0", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "hello",
-      limit: 0,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects limit > 50", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "hello",
-      limit: 51,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("accepts limit of 50", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "hello",
-      limit: 50,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("coerces a string limit, as the route's query string parses (#7167 DD1)", () => {
-    const result = contentSearchQuerySchema.safeParse({ q: "hello", limit: "5" });
-    expect(result.success).toBe(true);
-    expect(result.data!.limit).toBe(5);
-  });
-
-  it("rejects an unknown type string", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "hello",
-      type: "NotAType",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects missing q (malformed input)", () => {
-    const result = contentSearchQuerySchema.safeParse({});
-    expect(result.success).toBe(false);
-  });
-
-  it("accepts a category slug from the registry (#5831)", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "roof",
-      category: "roofing",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects a category slug outside the registry with an enum error (#5831)", () => {
-    const result = contentSearchQuerySchema.safeParse({
-      q: "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 = contentSearchQuerySchema.safeParse({
-      q: "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(
-      { q: "roof", category: "roofing" },
-      root,
-    );
-    expect(result.items.map((r) => r.slug)).toEqual(["roof-replacement"]);
-  });
-
-  it("returns every match when no category is passed", async () => {
-    const result = await ailkSearchContent({ q: "roof" }, root);
-    expect(result.items.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(
-      { q: "roof", category: "legal" },
-      root,
-    );
-    expect(result.items).toEqual([]);
-  });
-});
-
-describe("ailkSearchContent handler", () => {
-  it("returns the route's ItemList on a known query", async () => {
-    const result = await ailkSearchContent({ q: "launch" }, CONTENT_ROOT);
-    expect(result["@context"]).toBe("https://schema.org");
-    expect(result["@type"]).toBe("ItemList");
-    expect(result.query).toBe("launch");
-    expect(Array.isArray(result.items)).toBe(true);
-    expect(result.totalItems).toBe(result.items.length);
-  });
-
-  it("result items have required shape fields", async () => {
-    const result = await ailkSearchContent({ q: "launch" }, CONTENT_ROOT);
-    for (const item of result.items) {
-      expect(typeof item.slug).toBe("string");
-      expect(typeof item.type).toBe("string");
-      expect(typeof item.title).toBe("string");
-      expect(typeof item.snippet).toBe("string");
-      expect(typeof item.score).toBe("number");
-    }
-  });
-
-  it("returns an empty ItemList for a query that matches nothing", async () => {
-    const result = await ailkSearchContent(
-      { q: "xqzxqzxqzxqz_no_match_ever" },
-      CONTENT_ROOT,
-    );
-    expect(result.items).toEqual([]);
-    expect(result.totalItems).toBe(0);
-  });
-
-  it("respects limit option", async () => {
-    const result = await ailkSearchContent(
-      { q: "a", limit: 1 },
-      CONTENT_ROOT,
-    );
-    expect(result.items.length).toBeLessThanOrEqual(1);
-  });
-
-  it("output validates against contentSearchResultSchema", async () => {
-    const result = await ailkSearchContent({ q: "launch" }, CONTENT_ROOT);
-    const parsed = contentSearchResultSchema.safeParse(result);
-    expect(parsed.success).toBe(true);
-  });
-});
-
-describe("architectural guard — no console calls", () => {
-  it("apps/mcp/src/tools/search_content.ts does not call console.*", () => {
-    const src = readFileSync(
-      resolve(__dirname, "../src/tools/search_content.ts"),
-      "utf-8",
-    );
-    expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
-  });
-});