create-ailk 0.1.0

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

@@ -0,0 +1,201 @@
+/**
+ * Tests for the create_page MCP tool handler.
+ *
+ * D14a Stage 1 Unit C — Layer 1 / Layer 2 acceptance criteria mapped here:
+ *   - Free tier → canonical payment_required body, no adapter call.
+ *   - Bad frontmatter → validation_failed, no adapter call.
+ *   - Slug-already-exists → conflict body with details.existingVersion echoed
+ *     (so the agent can pivot to update without re-fetch).
+ *   - Pro tier + valid input + new slug → { page, version } success body.
+ *
+ * Adapter is injected as the second argument so this unit test does not need
+ * Stage 1 Unit A's MDX implementation in place. The default adapter resolution
+ * (createMdxAdapter against process.cwd()/content) is exercised by integration
+ * tests once Unit A lands.
+ */
+
+import { AdapterWriteError, type ContentAdapter } from "@working-theory/content-adapters";
+
+const mockCheckLicense = jest.fn();
+
+jest.mock("@working-theory/license", () => ({
+  checkLicense: (...args: unknown[]) => mockCheckLicense(...args),
+}));
+
+import { ailkCreatePage } from "../src/tools/create_page.js";
+
+interface AdapterCalls {
+  createPage: jest.Mock;
+  getPageBySlug: jest.Mock;
+  getPageVersion: jest.Mock;
+}
+
+function makeAdapter(overrides: Partial<AdapterCalls> = {}): ContentAdapter {
+  const calls: AdapterCalls = {
+    createPage: jest.fn(),
+    getPageBySlug: jest.fn().mockResolvedValue(null),
+    getPageVersion: jest.fn(),
+    ...overrides,
+  };
+  // eslint-disable-next-line no-restricted-syntax -- #506/#507: pre-existing test-hygiene violation
+  return {
+    getPageBySlug: calls.getPageBySlug,
+    listPages: jest.fn().mockResolvedValue([]),
+    getDetailBySlug: jest.fn().mockResolvedValue(null),
+    listDetail: jest.fn().mockResolvedValue([]),
+    searchPages: jest.fn().mockResolvedValue([]),
+    extractStructuredData: jest.fn().mockResolvedValue(null),
+    createPage: calls.createPage,
+    updatePage: jest.fn(),
+    deletePage: jest.fn(),
+    getPageVersion: calls.getPageVersion,
+  } as unknown as ContentAdapter;
+}
+
+const VALID_INPUT = {
+  type: "Product" as const,
+  slug: "widget-pro",
+  page: {
+    title: "Widget Pro",
+    description: "The professional widget.",
+  },
+  body: "# Widget Pro\n\nProfessional-grade widget.",
+};
+
+describe("ailkCreatePage", () => {
+  beforeEach(() => {
+    mockCheckLicense.mockReset();
+  });
+
+  describe("license gating", () => {
+    it("returns canonical payment_required body for free tier; adapter not called", async () => {
+      mockCheckLicense.mockResolvedValue({
+        tier: "free",
+        plan: null,
+        features: [],
+        expiresAt: null,
+        revoked: false,
+      });
+      const adapter = makeAdapter();
+
+      const result = await ailkCreatePage(VALID_INPUT, adapter);
+
+      expect(result).toMatchObject({ error: "payment_required" });
+      expect(adapter.createPage).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("validation", () => {
+    beforeEach(() => {
+      mockCheckLicense.mockResolvedValue({
+        tier: "pro",
+        plan: "pro",
+        features: [],
+        expiresAt: null,
+        revoked: false,
+      });
+    });
+
+    it("returns validation_failed when frontmatter is missing required fields", async () => {
+      const adapter = makeAdapter();
+      const result = await ailkCreatePage(
+        {
+          ...VALID_INPUT,
+          page: { title: "Only title" }, // missing description
+        },
+        adapter,
+      );
+      expect(result).toMatchObject({ error: "validation_failed" });
+      expect(adapter.createPage).not.toHaveBeenCalled();
+    });
+
+    it("returns validation_failed when body is empty", async () => {
+      const adapter = makeAdapter();
+      const result = await ailkCreatePage(
+        { ...VALID_INPUT, body: "" },
+        adapter,
+      );
+      expect(result).toMatchObject({ error: "validation_failed" });
+      expect(adapter.createPage).not.toHaveBeenCalled();
+    });
+
+    it("returns validation_failed for unknown SchemaOrgType", async () => {
+      const adapter = makeAdapter();
+      const result = await ailkCreatePage(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        { ...VALID_INPUT, type: "NotAType" as any },
+        adapter,
+      );
+      expect(result).toMatchObject({ error: "validation_failed" });
+      expect(adapter.createPage).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("slug conflict", () => {
+    it("returns conflict with details.existingVersion when slug already exists", async () => {
+      mockCheckLicense.mockResolvedValue({
+        tier: "pro",
+        plan: "pro",
+        features: [],
+        expiresAt: null,
+        revoked: false,
+      });
+      const adapter = makeAdapter({
+        createPage: jest
+          .fn()
+          .mockRejectedValue(
+            new AdapterWriteError(
+              "conflict",
+              "Page already exists at Product/widget-pro.mdx",
+              { version: "abc123" },
+            ),
+          ),
+      });
+
+      const result = await ailkCreatePage(VALID_INPUT, adapter);
+
+      expect(result).toMatchObject({
+        error: "conflict",
+        details: { version: "abc123" },
+      });
+    });
+  });
+
+  describe("happy path", () => {
+    it("returns { page, version } when adapter succeeds", async () => {
+      mockCheckLicense.mockResolvedValue({
+        tier: "pro",
+        plan: "pro",
+        features: [],
+        expiresAt: null,
+        revoked: false,
+      });
+      const persistedPage = {
+        type: "Product" as const,
+        slug: "widget-pro",
+        title: "Widget Pro",
+        description: "The professional widget.",
+      };
+      const adapter = makeAdapter({
+        createPage: jest
+          .fn()
+          .mockResolvedValue({ page: persistedPage, version: "v1" }),
+      });
+
+      const result = await ailkCreatePage(VALID_INPUT, adapter);
+
+      expect(result).toEqual({ page: persistedPage, version: "v1" });
+      expect(adapter.createPage).toHaveBeenCalledTimes(1);
+      const callArgs = (adapter.createPage as jest.Mock).mock.calls[0];
+      expect(callArgs[0]).toBe("Product");
+      expect(callArgs[1]).toBe("widget-pro");
+      expect(callArgs[2]).toMatchObject({
+        type: "Product",
+        slug: "widget-pro",
+        title: "Widget Pro",
+        description: "The professional widget.",
+        body: "# Widget Pro\n\nProfessional-grade widget.",
+      });
+    });
+  });
+});

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

@@ -0,0 +1,176 @@
+/**
+ * Tests for the delete_page MCP tool handler.
+ *
+ * D14a Stage 1 Unit C — Layer 1 / Layer 2 acceptance criteria mapped here:
+ *   - Free tier → payment_required, no adapter call.
+ *   - Missing ifMatch → validation_failed.
+ *   - Stale ifMatch → conflict with details.currentVersion echoed.
+ *   - Slug not found → not_found body.
+ *   - Pro + matching ifMatch → { ok: true } success body.
+ */
+
+import { AdapterWriteError, type ContentAdapter } from "@working-theory/content-adapters";
+
+const mockCheckLicense = jest.fn();
+
+jest.mock("@working-theory/license", () => ({
+  checkLicense: (...args: unknown[]) => mockCheckLicense(...args),
+}));
+
+import { ailkDeletePage } from "../src/tools/delete_page.js";
+
+function makeAdapter(
+  overrides: Partial<{ deletePage: jest.Mock }> = {},
+): ContentAdapter {
+  // eslint-disable-next-line no-restricted-syntax -- #506/#507: pre-existing test-hygiene violation
+  return {
+    getPageBySlug: jest.fn().mockResolvedValue(null),
+    listPages: jest.fn().mockResolvedValue([]),
+    getDetailBySlug: jest.fn().mockResolvedValue(null),
+    listDetail: jest.fn().mockResolvedValue([]),
+    searchPages: jest.fn().mockResolvedValue([]),
+    extractStructuredData: jest.fn().mockResolvedValue(null),
+    createPage: jest.fn(),
+    updatePage: jest.fn(),
+    deletePage: overrides.deletePage ?? jest.fn().mockResolvedValue(undefined),
+    getPageVersion: jest.fn(),
+  } as unknown as ContentAdapter;
+}
+
+const VALID_INPUT = {
+  type: "Product" as const,
+  slug: "widget-pro",
+  ifMatch: "v1",
+};
+
+describe("ailkDeletePage", () => {
+  beforeEach(() => {
+    mockCheckLicense.mockReset();
+  });
+
+  it("returns payment_required for free tier; adapter not called", async () => {
+    mockCheckLicense.mockResolvedValue({
+      tier: "free",
+      plan: null,
+      features: [],
+      expiresAt: null,
+      revoked: false,
+    });
+    const adapter = makeAdapter();
+
+    const result = await ailkDeletePage(VALID_INPUT, adapter);
+
+    expect(result).toMatchObject({ error: "payment_required" });
+    expect(adapter.deletePage).not.toHaveBeenCalled();
+  });
+
+  it("returns validation_failed when slug violates SLUG_PATTERN (issue #398 — defence-in-depth parity with create/update)", async () => {
+    mockCheckLicense.mockResolvedValue({
+      tier: "pro",
+      plan: "pro",
+      features: [],
+      expiresAt: null,
+      revoked: false,
+    });
+    const adapter = makeAdapter();
+
+    const result = await ailkDeletePage(
+      { ...VALID_INPUT, slug: "../etc/passwd" },
+      adapter,
+    );
+
+    expect(result).toMatchObject({ error: "validation_failed" });
+    expect(adapter.deletePage).not.toHaveBeenCalled();
+  });
+
+  it("returns validation_failed when ifMatch is missing", async () => {
+    mockCheckLicense.mockResolvedValue({
+      tier: "pro",
+      plan: "pro",
+      features: [],
+      expiresAt: null,
+      revoked: false,
+    });
+    const adapter = makeAdapter();
+    const { ifMatch: _ignored, ...inputNoIfMatch } = VALID_INPUT;
+
+    const result = await ailkDeletePage(
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      inputNoIfMatch as any,
+      adapter,
+    );
+
+    expect(result).toMatchObject({ error: "validation_failed" });
+    expect(adapter.deletePage).not.toHaveBeenCalled();
+  });
+
+  it("returns conflict on stale ifMatch", async () => {
+    mockCheckLicense.mockResolvedValue({
+      tier: "pro",
+      plan: "pro",
+      features: [],
+      expiresAt: null,
+      revoked: false,
+    });
+    const adapter = makeAdapter({
+      deletePage: jest
+        .fn()
+        .mockRejectedValue(
+          new AdapterWriteError(
+            "conflict",
+            "Version mismatch on Product/widget-pro.mdx",
+            { currentVersion: "v9" },
+          ),
+        ),
+    });
+
+    const result = await ailkDeletePage(VALID_INPUT, adapter);
+
+    expect(result).toMatchObject({
+      error: "conflict",
+      details: { currentVersion: "v9" },
+    });
+  });
+
+  it("returns not_found when adapter signals missing slug", async () => {
+    mockCheckLicense.mockResolvedValue({
+      tier: "pro",
+      plan: "pro",
+      features: [],
+      expiresAt: null,
+      revoked: false,
+    });
+    const adapter = makeAdapter({
+      deletePage: jest
+        .fn()
+        .mockRejectedValue(
+          new AdapterWriteError(
+            "not_found",
+            "No page at Product/widget-pro.mdx",
+          ),
+        ),
+    });
+
+    const result = await ailkDeletePage(VALID_INPUT, adapter);
+
+    expect(result).toMatchObject({ error: "not_found" });
+  });
+
+  it("returns { ok: true } on happy path", async () => {
+    mockCheckLicense.mockResolvedValue({
+      tier: "pro",
+      plan: "pro",
+      features: [],
+      expiresAt: null,
+      revoked: false,
+    });
+    const adapter = makeAdapter();
+
+    const result = await ailkDeletePage(VALID_INPUT, adapter);
+
+    expect(result).toEqual({ ok: true });
+    expect(adapter.deletePage).toHaveBeenCalledWith("Product", "widget-pro", {
+      ifMatch: "v1",
+    });
+  });
+});

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

@@ -0,0 +1,82 @@
+/**
+ * Tests for the get_business_hours MCP tool handler.
+ *
+ * Acceptance criteria verified here:
+ * - getBusinessHoursInputSchema validates correct inputs (slug optional)
+ * - getBusinessHoursInputSchema rejects invalid slugs
+ * - ailkGetBusinessHours returns null for a slug with no content
+ * - ailkGetBusinessHours output shape is correct when data exists
+ * - Output validates against getBusinessHoursOutputSchema
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import {
+  ailkGetBusinessHours,
+  getBusinessHoursInputSchema,
+  getBusinessHoursOutputSchema,
+} from "../src/tools/get_business_hours.js";
+
+const REPO_ROOT = resolve(__dirname, "../../..");
+const CONTENT_ROOT = `${REPO_ROOT}/content`;
+
+describe("getBusinessHoursInputSchema", () => {
+  it("accepts empty input (slug is optional)", () => {
+    const result = getBusinessHoursInputSchema.safeParse({});
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts a valid slug", () => {
+    const result = getBusinessHoursInputSchema.safeParse({ slug: "home" });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects a slug with path traversal", () => {
+    const result = getBusinessHoursInputSchema.safeParse({
+      slug: "../etc/passwd",
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects a slug with uppercase letters", () => {
+    const result = getBusinessHoursInputSchema.safeParse({ slug: "Home" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects an empty slug string", () => {
+    const result = getBusinessHoursInputSchema.safeParse({ slug: "" });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("ailkGetBusinessHours handler", () => {
+  it("returns null for a slug with no matching content", async () => {
+    const result = await ailkGetBusinessHours(
+      { slug: "nonexistent-slug-xqz" },
+      CONTENT_ROOT,
+    );
+    expect(result).toBeNull();
+  });
+
+  it("returns an object or null for default slug", async () => {
+    const result = await ailkGetBusinessHours({}, CONTENT_ROOT);
+    expect(result === null || typeof result === "object").toBe(true);
+  });
+
+  it("output validates against getBusinessHoursOutputSchema", async () => {
+    const result = await ailkGetBusinessHours({}, CONTENT_ROOT);
+    const parsed = getBusinessHoursOutputSchema.safeParse(result);
+    expect(parsed.success).toBe(true);
+  });
+});
+
+describe("architectural guard — no console calls", () => {
+  it("apps/mcp/src/tools/get_business_hours.ts does not call console.*", () => {
+    const src = readFileSync(
+      resolve(__dirname, "../src/tools/get_business_hours.ts"),
+      "utf-8",
+    );
+    expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
+  });
+});

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

@@ -0,0 +1,80 @@
+/**
+ * Tests for the get_faq MCP tool handler.
+ *
+ * Acceptance criteria verified here:
+ * - getFaqInputSchema validates correct inputs (slug optional)
+ * - getFaqInputSchema rejects invalid slugs
+ * - ailkGetFaq returns null for a slug with no content
+ * - ailkGetFaq output shape is correct when data exists
+ * - Output validates against getFaqOutputSchema
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import {
+  ailkGetFaq,
+  getFaqInputSchema,
+  getFaqOutputSchema,
+} from "../src/tools/get_faq.js";
+
+const REPO_ROOT = resolve(__dirname, "../../..");
+const CONTENT_ROOT = `${REPO_ROOT}/content`;
+
+describe("getFaqInputSchema", () => {
+  it("accepts empty input (slug is optional)", () => {
+    const result = getFaqInputSchema.safeParse({});
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts a valid slug", () => {
+    const result = getFaqInputSchema.safeParse({ slug: "faq" });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects a slug with path traversal", () => {
+    const result = getFaqInputSchema.safeParse({ slug: "../etc/passwd" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects a slug with uppercase letters", () => {
+    const result = getFaqInputSchema.safeParse({ slug: "FAQ" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects an empty slug string", () => {
+    const result = getFaqInputSchema.safeParse({ slug: "" });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("ailkGetFaq handler", () => {
+  it("returns null for a slug with no matching content", async () => {
+    const result = await ailkGetFaq(
+      { slug: "nonexistent-slug-xqz" },
+      CONTENT_ROOT,
+    );
+    expect(result).toBeNull();
+  });
+
+  it("returns an object or null for default slug", async () => {
+    const result = await ailkGetFaq({}, CONTENT_ROOT);
+    expect(result === null || typeof result === "object").toBe(true);
+  });
+
+  it("output validates against getFaqOutputSchema when non-null", async () => {
+    const result = await ailkGetFaq({}, CONTENT_ROOT);
+    const parsed = getFaqOutputSchema.safeParse(result);
+    expect(parsed.success).toBe(true);
+  });
+});
+
+describe("architectural guard — no console calls", () => {
+  it("apps/mcp/src/tools/get_faq.ts does not call console.*", () => {
+    const src = readFileSync(
+      resolve(__dirname, "../src/tools/get_faq.ts"),
+      "utf-8",
+    );
+    expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
+  });
+});

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

@@ -0,0 +1,65 @@
+/**
+ * Tests for the get_locations MCP tool handler.
+ *
+ * Acceptance criteria verified here:
+ * - getLocationsInputSchema validates correct inputs (no required fields)
+ * - ailkGetLocations returns an array (empty or populated)
+ * - Output shape has the correct fields when locations exist
+ * - Output validates against getLocationsOutputSchema
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import {
+  ailkGetLocations,
+  getLocationsInputSchema,
+  getLocationsOutputSchema,
+} from "../src/tools/get_locations.js";
+
+const REPO_ROOT = resolve(__dirname, "../../..");
+const CONTENT_ROOT = `${REPO_ROOT}/content`;
+
+describe("getLocationsInputSchema", () => {
+  it("accepts empty input", () => {
+    const result = getLocationsInputSchema.safeParse({});
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects extra unknown fields (strict mode not applied — passthrough)", () => {
+    // Zod strips unknown fields by default (not strict); this should pass
+    const result = getLocationsInputSchema.safeParse({ unexpected: true });
+    expect(result.success).toBe(true);
+  });
+});
+
+describe("ailkGetLocations handler", () => {
+  it("returns an array (may be empty if no Place content exists)", async () => {
+    const result = await ailkGetLocations({}, CONTENT_ROOT);
+    expect(Array.isArray(result.locations)).toBe(true);
+  });
+
+  it("location items have required shape fields when array is non-empty", async () => {
+    const result = await ailkGetLocations({}, CONTENT_ROOT);
+    for (const loc of result.locations) {
+      expect(typeof loc.name).toBe("string");
+      expect(typeof loc.address).toBe("object");
+    }
+  });
+
+  it("output validates against getLocationsOutputSchema", async () => {
+    const result = await ailkGetLocations({}, CONTENT_ROOT);
+    const parsed = getLocationsOutputSchema.safeParse(result);
+    expect(parsed.success).toBe(true);
+  });
+});
+
+describe("architectural guard — no console calls", () => {
+  it("apps/mcp/src/tools/get_locations.ts does not call console.*", () => {
+    const src = readFileSync(
+      resolve(__dirname, "../src/tools/get_locations.ts"),
+      "utf-8",
+    );
+    expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
+  });
+});

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

@@ -0,0 +1,90 @@
+/**
+ * Tests for the get_offerings MCP tool handler.
+ *
+ * Acceptance criteria verified here:
+ * - getOfferingsInputSchema validates correct inputs (type optional: 'service'|'product')
+ * - getOfferingsInputSchema rejects invalid type values
+ * - ailkGetOfferings returns an array (empty or populated)
+ * - Output shape has the correct fields when offerings exist
+ * - Output validates against getOfferingsOutputSchema
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import {
+  ailkGetOfferings,
+  getOfferingsInputSchema,
+  getOfferingsOutputSchema,
+} from "../src/tools/get_offerings.js";
+
+const REPO_ROOT = resolve(__dirname, "../../..");
+const CONTENT_ROOT = `${REPO_ROOT}/content`;
+
+describe("getOfferingsInputSchema", () => {
+  it("accepts empty input (type is optional)", () => {
+    const result = getOfferingsInputSchema.safeParse({});
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts type: 'service'", () => {
+    const result = getOfferingsInputSchema.safeParse({ type: "service" });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts type: 'product'", () => {
+    const result = getOfferingsInputSchema.safeParse({ type: "product" });
+    expect(result.success).toBe(true);
+  });
+
+  it("rejects an unknown type string", () => {
+    const result = getOfferingsInputSchema.safeParse({ type: "offer" });
+    expect(result.success).toBe(false);
+  });
+
+  it("rejects a numeric type", () => {
+    const result = getOfferingsInputSchema.safeParse({ type: 42 });
+    expect(result.success).toBe(false);
+  });
+});
+
+describe("ailkGetOfferings handler", () => {
+  it("returns an array (may be empty if no Service/Product content)", async () => {
+    const result = await ailkGetOfferings({}, CONTENT_ROOT);
+    expect(Array.isArray(result.offerings)).toBe(true);
+  });
+
+  it("returns only services when type is 'service'", async () => {
+    const result = await ailkGetOfferings({ type: "service" }, CONTENT_ROOT);
+    expect(Array.isArray(result.offerings)).toBe(true);
+  });
+
+  it("returns only products when type is 'product'", async () => {
+    const result = await ailkGetOfferings({ type: "product" }, CONTENT_ROOT);
+    expect(Array.isArray(result.offerings)).toBe(true);
+  });
+
+  it("offering items have required shape fields when array is non-empty", async () => {
+    const result = await ailkGetOfferings({}, CONTENT_ROOT);
+    for (const offering of result.offerings) {
+      expect(typeof offering.name).toBe("string");
+      expect(typeof offering.description).toBe("string");
+    }
+  });
+
+  it("output validates against getOfferingsOutputSchema", async () => {
+    const result = await ailkGetOfferings({}, CONTENT_ROOT);
+    const parsed = getOfferingsOutputSchema.safeParse(result);
+    expect(parsed.success).toBe(true);
+  });
+});
+
+describe("architectural guard — no console calls", () => {
+  it("apps/mcp/src/tools/get_offerings.ts does not call console.*", () => {
+    const src = readFileSync(
+      resolve(__dirname, "../src/tools/get_offerings.ts"),
+      "utf-8",
+    );
+    expect(src).not.toMatch(/\bconsole\.(log|warn|error|info|debug)\b/);
+  });
+});