create-ailk 0.23.0 → 0.25.1

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

@@ -1,256 +0,0 @@
-/**
- * Tests for the search_content MCP tool handler.
- *
- * Acceptance criteria verified here:
- * - searchContentInputSchema validates correct inputs (query required, type + limit optional)
- * - searchContentInputSchema rejects query longer than 200 chars
- * - searchContentInputSchema rejects limit > 50
- * - searchContentInputSchema rejects empty query
- * - 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 { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-
-import {
-  ailkSearchContent,
-  searchContentInputSchema,
-  searchContentOutputSchema,
-} from "../src/tools/search_content.js";
-
-const REPO_ROOT = resolve(__dirname, "../../..");
-const CONTENT_ROOT = `${REPO_ROOT}/content`;
-
-describe("searchContentInputSchema", () => {
-  it("accepts a valid query", () => {
-    const result = searchContentInputSchema.safeParse({ query: "hello" });
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts query with optional type filter", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
-      type: "HomePage",
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("accepts query with optional limit", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
-      limit: 10,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects an empty query", () => {
-    const result = searchContentInputSchema.safeParse({ query: "" });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects a query longer than 200 chars", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "a".repeat(201),
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("accepts a query exactly 200 chars", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "a".repeat(200),
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects limit of 0", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
-      limit: 0,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects limit > 50", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
-      limit: 51,
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("accepts limit of 50", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
-      limit: 50,
-    });
-    expect(result.success).toBe(true);
-  });
-
-  it("rejects an unknown type string", () => {
-    const result = searchContentInputSchema.safeParse({
-      query: "hello",
-      type: "NotAType",
-    });
-    expect(result.success).toBe(false);
-  });
-
-  it("rejects missing query (malformed input)", () => {
-    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", () => {
-  it("returns a results array on a known query", async () => {
-    const result = await ailkSearchContent({ query: "launch" }, CONTENT_ROOT);
-    expect(Array.isArray(result.results)).toBe(true);
-  });
-
-  it("result items have required shape fields", async () => {
-    const result = await ailkSearchContent({ query: "launch" }, CONTENT_ROOT);
-    for (const item of result.results) {
-      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 empty results for a query that matches nothing", async () => {
-    const result = await ailkSearchContent(
-      { query: "xqzxqzxqzxqz_no_match_ever" },
-      CONTENT_ROOT,
-    );
-    expect(result.results).toEqual([]);
-  });
-
-  it("respects limit option", async () => {
-    const result = await ailkSearchContent(
-      { query: "a", limit: 1 },
-      CONTENT_ROOT,
-    );
-    expect(result.results.length).toBeLessThanOrEqual(1);
-  });
-
-  it("output validates against searchContentOutputSchema", async () => {
-    const result = await ailkSearchContent({ query: "launch" }, CONTENT_ROOT);
-    const parsed = searchContentOutputSchema.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/);
-  });
-});

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

@@ -1,388 +0,0 @@
-/**
- * Tests for the MCP server bootstrap.
- *
- * Acceptance criteria verified here:
- * - Server instance is created without crashing
- * - list_pages and read_content tools are registered
- * - Each registered tool has a non-empty description
- *
- * 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.
- *
- * #7136: the five licence-feature-tagged tools — registration in both gate
- * modes, the once-per-boot warning (`reportUnlicensedProTools`), and its
- * place in `index.ts`'s boot order.
- *
- * Strategy: createMcpServer() returns the McpServer instance before connecting
- * to a transport. Tests inspect server._registeredTools (plain object in SDK
- * v1.x — no public API exists for listing tools without a live transport).
- * If the SDK renames this field, update the (server as any)._registeredTools
- * casts below. Pinned to @modelcontextprotocol/sdk ^1.29.0.
- */
-
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import {
-  __setMcpCommerceClaimForTest,
-  __setMcpFeatureGateForTest,
-  __setMcpHeldFeaturesForTest,
-  resetMcpCommerceClaim,
-} from "../src/lib/commerce-claim.js";
-import {
-  createMcpServer,
-  listRegisteredTools,
-  reportUnlicensedProTools,
-} from "../src/server.js";
-
-// The topology seam's UNSERVED_MCP_TOOLS (#8070 D7), made switchable so one
-// suite can stand in for a hub ([] — the committed seam, and every other
-// case in this file) and a spoke (["create_project"]).
-const mockSeam: { unserved: readonly string[] } = { unserved: [] };
-// eslint-disable-next-line no-restricted-syntax -- the generated topology seam IS the boundary under test (spec 8070 AC-8b mocks its list); every other export passes through from the real module
-jest.mock("../src/lib/topology.generated.js", () => {
-  const actual = jest.requireActual("../src/lib/topology.generated.js");
-  // A getter defined, not spread: the factory runs before `mockSeam` is
-  // initialised, so the list must be read at use, never at mock time.
-  const mocked = { ...actual };
-  Object.defineProperty(mocked, "UNSERVED_MCP_TOOLS", {
-    enumerable: true,
-    get: () => mockSeam.unserved,
-  });
-  return mocked;
-});
-
-describe("createMcpServer", () => {
-  it("creates an McpServer without throwing", () => {
-    expect(() => createMcpServer()).not.toThrow();
-  });
-
-  it("returns an object with a connect method (MCP server shape)", () => {
-    const server = createMcpServer();
-    expect(typeof server.connect).toBe("function");
-  });
-});
-
-describe("list_pages tool registration", () => {
-  it("server has the list_pages 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("list_pages" in tools).toBe(true);
-  });
-
-  it("list_pages 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["list_pages"];
-    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("read_content tool registration", () => {
-  it("server has the read_content 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("read_content" in tools).toBe(true);
-  });
-
-  it("read_content 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["read_content"];
-    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);
-  });
-});
-
-// ── I4 tools ──────────────────────────────────────────────────────────────────
-
-const I4_TOOLS = [
-  "search_content",
-  "get_site_info",
-  "get_business_hours",
-  "get_locations",
-  "get_offerings",
-  "get_pricing",
-  "get_faq",
-] as const;
-
-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("start_purchase" in tools).toBe(false);
-    expect(listRegisteredTools().map((t) => t.name)).not.toContain(
-      "start_purchase",
-    );
-  });
-
-  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 }
-    >;
-
-    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());
-  });
-});
-
-describe("create_project on a spoke — the seam's UNSERVED_MCP_TOOLS (#8070 D7, AC-8b)", () => {
-  afterEach(() => {
-    mockSeam.unserved = [];
-  });
-
-  it("a spoke's list (['create_project']) keeps it out of registration", () => {
-    mockSeam.unserved = ["create_project"];
-
-    expect(listRegisteredTools().map((t) => t.name)).not.toContain(
-      "create_project",
-    );
-    const server = createMcpServer();
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- the SDK exposes no public tool listing; same cast as the suites above
-    const tools = (server as any)._registeredTools as Record<string, unknown>;
-    expect("create_project" in tools).toBe(false);
-  });
-
-  it("a hub's list ([]) registers it", () => {
-    mockSeam.unserved = [];
-
-    expect(listRegisteredTools().map((t) => t.name)).toContain(
-      "create_project",
-    );
-  });
-
-  it("withholding it changes nothing else", () => {
-    const hub = listRegisteredTools().map((t) => t.name);
-    mockSeam.unserved = ["create_project"];
-    const spoke = listRegisteredTools().map((t) => t.name);
-
-    expect(spoke).toEqual(hub.filter((name) => name !== "create_project"));
-  });
-});
-
-describe("the six licence-feature tools — one-release warning cycle (#7136)", () => {
-  const FLOW_PAIR = ["get_flow", "submit_flow_step"];
-  const BOOKING_TOOLS = [
-    "list_availability",
-    "get_event_meta",
-    "list_meetings",
-    "create_booking",
-  ];
-  const SIX = [...FLOW_PAIR, ...BOOKING_TOOLS];
-  const FEATURE_OF: Record<string, string> = {
-    get_flow: "flows-deliverables",
-    submit_flow_step: "flows-deliverables",
-    list_availability: "scheduling",
-    get_event_meta: "scheduling",
-    list_meetings: "scheduling",
-    create_booking: "scheduling",
-  };
-
-  const priorEnabledModules = process.env.AILK_ENABLED_MODULES;
-
-  beforeEach(() => {
-    process.env.AILK_ENABLED_MODULES = "scheduling,signal-collectors";
-  });
-
-  afterEach(() => {
-    resetMcpCommerceClaim();
-    jest.restoreAllMocks();
-  });
-
-  afterAll(() => {
-    if (priorEnabledModules === undefined) {
-      delete process.env.AILK_ENABLED_MODULES;
-    } else {
-      process.env.AILK_ENABLED_MODULES = priorEnabledModules;
-    }
-  });
-
-  function registeredKeys(): string[] {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- #506/#507: mirrors the registration assertions above
-    return Object.keys((createMcpServer() as any)._registeredTools);
-  }
-
-  it("warn mode, no feature held: all six still register and serve", () => {
-    __setMcpHeldFeaturesForTest([]);
-
-    const listed = listRegisteredTools().map((t) => t.name);
-    const registered = registeredKeys();
-    for (const name of SIX) {
-      expect(listed).toContain(name);
-      expect(registered).toContain(name);
-    }
-  });
-
-  it("warn mode, no feature held: one warning per tool, naming the tool, its feature and the next release", () => {
-    __setMcpHeldFeaturesForTest([]);
-    const warn = jest.fn();
-
-    const names = reportUnlicensedProTools(warn);
-
-    expect(names.slice().sort()).toEqual(SIX.slice().sort());
-    expect(warn).toHaveBeenCalledTimes(6);
-    for (const name of SIX) {
-      const message = warn.mock.calls
-        .map(([m]) => m as string)
-        .find((m) => m.includes(`"${name}"`));
-      expect(message).toBeDefined();
-      expect(message).toContain(`"${FEATURE_OF[name]}"`);
-      expect(message).toContain("next release stops serving it");
-    }
-  });
-
-  it("warns only for tools whose feature is unheld", () => {
-    const warn = jest.fn();
-
-    __setMcpHeldFeaturesForTest(["scheduling"]);
-    expect(reportUnlicensedProTools(warn).sort()).toEqual(
-      FLOW_PAIR.slice().sort(),
-    );
-    expect(warn).toHaveBeenCalledTimes(2);
-
-    warn.mockClear();
-    __setMcpHeldFeaturesForTest(["scheduling", "flows-deliverables"]);
-    expect(reportUnlicensedProTools(warn)).toEqual([]);
-    expect(warn).not.toHaveBeenCalled();
-  });
-
-  it("never warns about a tool whose module is off", () => {
-    process.env.AILK_ENABLED_MODULES = "signal-collectors";
-    __setMcpHeldFeaturesForTest([]);
-    const warn = jest.fn();
-
-    expect(reportUnlicensedProTools(warn).sort()).toEqual(
-      FLOW_PAIR.slice().sort(),
-    );
-    expect(warn).toHaveBeenCalledTimes(2);
-  });
-
-  it("refuse mode, no feature held: none of the six registers, and nothing is warned", () => {
-    __setMcpFeatureGateForTest("refuse");
-    __setMcpHeldFeaturesForTest([]);
-    const warn = jest.fn();
-
-    expect(reportUnlicensedProTools(warn)).toEqual([]);
-    expect(warn).not.toHaveBeenCalled();
-    const listed = listRegisteredTools().map((t) => t.name);
-    const registered = registeredKeys();
-    for (const name of SIX) {
-      expect(listed).not.toContain(name);
-      expect(registered).not.toContain(name);
-    }
-  });
-
-  it("refuse mode registers exactly the tools whose feature is held", () => {
-    __setMcpFeatureGateForTest("refuse");
-    __setMcpHeldFeaturesForTest(["scheduling"]);
-
-    const registered = registeredKeys();
-    for (const name of BOOKING_TOOLS) expect(registered).toContain(name);
-    for (const name of FLOW_PAIR) expect(registered).not.toContain(name);
-  });
-
-  it("building a server never warns — the warning is once per boot, not per HTTP session", () => {
-    __setMcpHeldFeaturesForTest([]);
-    const consoleWarn = jest
-      .spyOn(console, "warn")
-      .mockImplementation(() => undefined);
-
-    createMcpServer();
-    createMcpServer();
-
-    expect(consoleWarn).not.toHaveBeenCalled();
-  });
-
-  it("the boot reports after the claim resolves, and index.ts boots before either transport starts", () => {
-    // The boot sequence lives in boot.ts's bootMcp() since #8070 D2.
-    const boot = readFileSync(join(__dirname, "../src/boot.ts"), "utf8");
-    const init = boot.indexOf("await initMcpCommerceClaim()");
-    const report = boot.indexOf("reportUnlicensedProTools(");
-
-    expect(init).toBeGreaterThan(-1);
-    expect(report).toBeGreaterThan(init);
-
-    const index = readFileSync(join(__dirname, "../src/index.ts"), "utf8");
-    const bootCall = index.indexOf("await bootMcp()");
-    const transport = index.indexOf('if (transport === "http")');
-
-    expect(bootCall).toBeGreaterThan(-1);
-    expect(transport).toBeGreaterThan(bootCall);
-  });
-
-  it("server.ts never writes to stdout — the stdio transport's JSON-RPC channel", () => {
-    const server = readFileSync(join(__dirname, "../src/server.ts"), "utf8");
-    expect(server).not.toContain("console.log");
-  });
-});