create-ailk 0.1.0

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

@@ -0,0 +1,163 @@
+/**
+ * Tests for the request_callback 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.callback, 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 { ailkRequestCallback } from "../src/tools/request_callback.js";
+
+jest.mock("@working-theory/api-client", () => ({
+  apiClient: {
+    leads: {
+      callback: jest.fn(),
+    },
+  },
+}));
+
+ 
+const { apiClient } = require("@working-theory/api-client") as {
+  apiClient: { leads: { callback: jest.Mock } };
+};
+
+const VALID_INPUT = {
+  name: "Jane Smith",
+  phone: "+15555550100",
+};
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("ailkRequestCallback — input validation", () => {
+  it("rejects malformed input (missing required fields) without calling api-client", async () => {
+    const result = await ailkRequestCallback({} as never);
+
+    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.callback).not.toHaveBeenCalled();
+  });
+});
+
+describe("ailkRequestCallback — happy path", () => {
+  it("forwards canonical body to api-client and returns ok:true with id and persisted", async () => {
+    apiClient.leads.callback.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "cb_def456", persisted: "file" },
+    });
+
+    const result = await ailkRequestCallback(VALID_INPUT);
+
+    expect(apiClient.leads.callback).toHaveBeenCalledWith({
+      siteId: "default",
+      name: "Jane Smith",
+      phone: "+15555550100",
+      payload: {},
+    });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.id).toBe("cb_def456");
+      expect(result.persisted).toBe("file");
+    }
+  });
+});
+
+describe("ailkRequestCallback — API error mapping", () => {
+  it("maps API 400 to { ok: false, error: { kind: 'api_error', status: 400 } }", async () => {
+    apiClient.leads.callback.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      body: { error: "bad_request" },
+    });
+
+    const result = await ailkRequestCallback(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.callback.mockResolvedValueOnce({
+      ok: false,
+      status: 503,
+      body: { error: "service_unavailable" },
+    });
+
+    const result = await ailkRequestCallback(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.callback.mockResolvedValueOnce({
+      ok: false,
+      status: 429,
+      body: { error: "rate_limited" },
+    });
+
+    const result = await ailkRequestCallback(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("ailkRequestCallback — siteId default", () => {
+  it("uses siteId 'default' when AILK_SITE_ID is unset", async () => {
+    delete process.env.AILK_SITE_ID;
+    apiClient.leads.callback.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "cb_default", persisted: "file" },
+    });
+
+    await ailkRequestCallback(VALID_INPUT);
+
+    const call = apiClient.leads.callback.mock.calls[0][0] as { siteId: string };
+    expect(call.siteId).toBe("default");
+  });
+});
+
+describe("ailkRequestCallback — 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.callback.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "cb_override", persisted: "file" },
+    });
+
+    await ailkRequestCallback(VALID_INPUT);
+
+    const call = apiClient.leads.callback.mock.calls[0][0] as { siteId: string };
+    expect(call.siteId).toBe("site-abc");
+  });
+});

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

@@ -0,0 +1,153 @@
+/**
+ * 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
+ */
+
+import { readFileSync } from "node:fs";
+import { 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);
+  });
+});
+
+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

@@ -0,0 +1,115 @@
+/**
+ * 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: `start_purchase` registration is asserted in
+ * `purchase-disabled.test.ts` as NOT-registered (S15a / issue #610). The
+ * prior `start_purchase` assertions in this file moved there.
+ *
+ * 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 { createMcpServer } from "../src/server.js";
+
+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);
+  });
+});

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

@@ -0,0 +1,165 @@
+/**
+ * Tests for the submit_lead 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.submit, 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 { ailkCaptureLead } from "../src/tools/capture_lead.js";
+
+// Mock @working-theory/api-client before importing the handler
+jest.mock("@working-theory/api-client", () => ({
+  apiClient: {
+    leads: {
+      submit: jest.fn(),
+    },
+  },
+}));
+
+ 
+const { apiClient } = require("@working-theory/api-client") as {
+  apiClient: { leads: { submit: jest.Mock } };
+};
+
+const VALID_INPUT = {
+  name: "Jane Smith",
+  email: "jane@example.com",
+  message: "I am interested in your services.",
+};
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("ailkCaptureLead — input validation", () => {
+  it("rejects malformed input (missing required fields) without calling api-client", async () => {
+    const result = await ailkCaptureLead({ email: "not-an-email" } as never);
+
+    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.submit).not.toHaveBeenCalled();
+  });
+});
+
+describe("ailkCaptureLead — happy path", () => {
+  it("forwards canonical body to api-client and returns ok:true with id and persisted", async () => {
+    apiClient.leads.submit.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "lead_abc123", persisted: "db" },
+    });
+
+    const result = await ailkCaptureLead(VALID_INPUT);
+
+    expect(apiClient.leads.submit).toHaveBeenCalledWith({
+      siteId: "default",
+      source: "mcp",
+      email: "jane@example.com",
+      payload: { name: "Jane Smith", message: "I am interested in your services." },
+    });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.id).toBe("lead_abc123");
+      expect(result.persisted).toBe("db");
+    }
+  });
+});
+
+describe("ailkCaptureLead — API error mapping", () => {
+  it("maps API 400 to { ok: false, error: { kind: 'api_error', status: 400 } }", async () => {
+    apiClient.leads.submit.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      body: { error: "bad_request" },
+    });
+
+    const result = await ailkCaptureLead(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.submit.mockResolvedValueOnce({
+      ok: false,
+      status: 503,
+      body: { error: "service_unavailable" },
+    });
+
+    const result = await ailkCaptureLead(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.submit.mockResolvedValueOnce({
+      ok: false,
+      status: 429,
+      body: { error: "rate_limited" },
+    });
+
+    const result = await ailkCaptureLead(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("ailkCaptureLead — siteId default", () => {
+  it("uses siteId 'default' when AILK_SITE_ID is unset", async () => {
+    delete process.env.AILK_SITE_ID;
+    apiClient.leads.submit.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "lead_default", persisted: "db" },
+    });
+
+    await ailkCaptureLead(VALID_INPUT);
+
+    const call = apiClient.leads.submit.mock.calls[0][0] as { siteId: string };
+    expect(call.siteId).toBe("default");
+  });
+});
+
+describe("ailkCaptureLead — 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.submit.mockResolvedValueOnce({
+      ok: true,
+      body: { id: "lead_override", persisted: "db" },
+    });
+
+    await ailkCaptureLead(VALID_INPUT);
+
+    const call = apiClient.leads.submit.mock.calls[0][0] as { siteId: string };
+    expect(call.siteId).toBe("site-abc");
+  });
+});