@rubytech/create-maxy-code 0.1.614 → 0.1.616

package/payload/platform/lib/aeo-llms-txt-writer/src/__tests__/write-llms-txt.test.ts

@@ -0,0 +1,391 @@
+import { describe, expect, it } from "vitest";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { Session } from "neo4j-driver";
+import { writeLlmsTxt } from "../index.js";
+
+interface FakeDoc {
+  title: string | null;
+  url: string | null;
+  summary: string | null;
+  body?: string | null;
+}
+
+interface FakeSection {
+  url: string;
+  title: string | null;
+  body: string | null;
+  position: number;
+}
+
+/**
+ * The lib runs two queries: a flat document query, then a section query
+ * scoped to the URLs that survived filtering. The fake dispatches on
+ * whether the Cypher mentions HAS_SECTION.
+ */
+function fakeSession(docs: FakeDoc[], sections: FakeSection[] = []) {
+  const queries: string[] = [];
+  let closed = false;
+  const session = {
+    async run(cypher: string, params: Record<string, unknown>) {
+      queries.push(cypher);
+      if (cypher.includes("HAS_SECTION")) {
+        const urls = (params.urls as string[]) ?? [];
+        const rows = sections
+          .filter((s) => urls.includes(s.url))
+          .sort((a, b) =>
+            a.url === b.url ? a.position - b.position : a.url < b.url ? -1 : 1,
+          );
+        return {
+          records: rows.map((s) => ({
+            get: (k: string) =>
+              k === "url"
+                ? s.url
+                : k === "title"
+                  ? s.title
+                  : k === "body"
+                    ? (s.body ?? "")
+                    : s.position,
+          })),
+        };
+      }
+      const rows = [...docs].sort((a, b) =>
+        (a.title ?? "") < (b.title ?? "") ? -1 : 1,
+      );
+      return {
+        records: rows.map((d) => ({
+          get: (k: string) =>
+            k === "title"
+              ? d.title
+              : k === "url"
+                ? d.url
+                : k === "summary"
+                  ? d.summary
+                  : (d.body ?? ""),
+        })),
+      };
+    },
+    async close() {
+      closed = true;
+    },
+  };
+  return {
+    deps: { getSession: () => session as unknown as Session },
+    queries,
+    wasClosed: () => closed,
+  };
+}
+
+describe("writeLlmsTxt — site scoping", () => {
+  it("includes only documents whose url starts with siteOrigin", async () => {
+    const f = fakeSession([
+      { title: "Mine", url: "https://a.example/x", summary: "page a" },
+      { title: "Theirs", url: "https://b.example/y", summary: "page b" },
+    ]);
+    const r = await writeLlmsTxt(
+      {
+        accountId: "acct",
+        siteName: "A",
+        siteOrigin: "https://a.example",
+      },
+      f.deps,
+    );
+    expect(r.pageCount).toBe(1);
+    expect(r.skippedOtherSite).toBe(1);
+    expect(r.llmsTxt).toContain("https://a.example/x");
+    expect(r.llmsTxt).not.toContain("b.example");
+  });
+
+  it("still counts documents missing a url or title separately", async () => {
+    const f = fakeSession([
+      { title: "Mine", url: "https://a.example/x", summary: "page a" },
+      { title: "No url", url: null, summary: "orphan" },
+      { title: null, url: "https://a.example/z", summary: "no title" },
+      { title: "Theirs", url: "https://b.example/y", summary: "page b" },
+    ]);
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    expect(r.pageCount).toBe(1);
+    expect(r.skippedNoUrl).toBe(2);
+    expect(r.skippedOtherSite).toBe(1);
+  });
+
+  it("normalises a trailing slash off the origin", async () => {
+    const f = fakeSession([
+      { title: "Mine", url: "https://a.example/x", summary: "page a" },
+    ]);
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example/" },
+      f.deps,
+    );
+    expect(r.pageCount).toBe(1);
+  });
+
+  it("does not match a different host that shares the origin as a prefix", async () => {
+    const f = fakeSession([
+      { title: "Mine", url: "https://a.example/x", summary: "page a" },
+      { title: "Lookalike", url: "https://a.example.evil/x", summary: "evil" },
+      { title: "Suffixed", url: "https://a.exampleX/x", summary: "other" },
+      { title: "Bare", url: "https://a.example", summary: "root, no slash" },
+    ]);
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    expect(r.pageCount).toBe(2);
+    expect(r.skippedOtherSite).toBe(2);
+    expect(r.llmsTxt).not.toContain("a.example.evil");
+    expect(r.llmsTxt).not.toContain("a.exampleX");
+  });
+
+  it("throws on an origin that is not an absolute http(s) URL", async () => {
+    const f = fakeSession([]);
+    for (const bad of ["maxy.institute", "", "/institute", "ftp://a.example"]) {
+      await expect(
+        writeLlmsTxt(
+          { accountId: "acct", siteName: "A", siteOrigin: bad },
+          f.deps,
+        ),
+      ).rejects.toThrow(/siteOrigin must be an absolute http\(s\) URL/);
+    }
+  });
+});
+
+describe("writeLlmsTxt — full text", () => {
+  it("renders a page's sections in position order under h2 headings", async () => {
+    const f = fakeSession(
+      [{ title: "Chapter one", url: "https://a.example/one", summary: "sum" }],
+      [
+        {
+          url: "https://a.example/one",
+          title: "Third",
+          body: "gamma",
+          position: 2,
+        },
+        {
+          url: "https://a.example/one",
+          title: "First",
+          body: "alpha",
+          position: 0,
+        },
+        {
+          url: "https://a.example/one",
+          title: "Second",
+          body: "beta",
+          position: 1,
+        },
+      ],
+    );
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    const alpha = r.llmsFullTxt.indexOf("alpha");
+    const beta = r.llmsFullTxt.indexOf("beta");
+    const gamma = r.llmsFullTxt.indexOf("gamma");
+    expect(alpha).toBeGreaterThan(-1);
+    expect(alpha).toBeLessThan(beta);
+    expect(beta).toBeLessThan(gamma);
+    expect(r.llmsFullTxt).toContain("## First");
+    // Not a size comparison: on a small fixture the index legitimately
+    // exceeds the full file. What discriminates is that the section prose
+    // reaches llms-full.txt and never reaches the index.
+    expect(r.pagesWithFullText).toBe(1);
+    expect(r.sectionCount).toBe(3);
+    expect(r.llmsTxt).not.toContain("alpha");
+  });
+
+  it("falls back to the document body when the page has no sections", async () => {
+    const f = fakeSession([
+      {
+        title: "Standalone",
+        url: "https://a.example/s",
+        summary: "sum",
+        body: "the whole document body",
+      },
+    ]);
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    expect(r.llmsFullTxt).toContain("the whole document body");
+  });
+
+  it("emits the summary and counts the page when it has neither sections nor a body", async () => {
+    const f = fakeSession([
+      { title: "Thin", url: "https://a.example/t", summary: "only a summary" },
+    ]);
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    expect(r.llmsFullTxt).toContain("only a summary");
+    expect(r.pagesWithFullText).toBe(0);
+    expect(r.pagesWithoutFullText).toBe(1);
+  });
+
+  it("demotes every in-body h1, not just the first", async () => {
+    const f = fakeSession(
+      [{ title: "Multi", url: "https://a.example/m", summary: "sum" }],
+      [
+        {
+          url: "https://a.example/m",
+          title: "Body",
+          body: "# one\ntext\n# two\nmore",
+          position: 0,
+        },
+      ],
+    );
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    expect(r.llmsFullTxt).toContain("## one");
+    expect(r.llmsFullTxt).toContain("## two");
+    expect(r.llmsFullTxt).not.toMatch(/^# one$/m);
+    expect(r.llmsFullTxt).not.toMatch(/^# two$/m);
+  });
+
+  it("never emits abstract as full text", async () => {
+    // The document query no longer reads d.abstract at all: the fake
+    // returns only what the query asks for, and body is empty here.
+    const f = fakeSession([
+      {
+        title: "Abstracted",
+        url: "https://a.example/a",
+        summary: "sum",
+        body: "",
+      },
+    ]);
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    expect(r.pagesWithoutFullText).toBe(1);
+    const docQuery = f.queries.find((q) => !q.includes("HAS_SECTION")) ?? "";
+    expect(docQuery).not.toContain("abstract");
+  });
+
+  it("gives every document sharing a url its own sections", async () => {
+    const f = fakeSession(
+      [
+        { title: "First copy", url: "https://a.example/dup", summary: "one" },
+        { title: "Second copy", url: "https://a.example/dup", summary: "two" },
+      ],
+      [
+        {
+          url: "https://a.example/dup",
+          title: "Body",
+          body: "shared prose",
+          position: 0,
+        },
+      ],
+    );
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    expect(r.pageCount).toBe(2);
+    expect(r.pagesWithFullText).toBe(2);
+    expect(r.pagesWithoutFullText).toBe(0);
+  });
+
+  it("escapes a section title that carries a newline", async () => {
+    const f = fakeSession(
+      [{ title: "Injected", url: "https://a.example/i", summary: "sum" }],
+      [
+        {
+          url: "https://a.example/i",
+          title: "Part one\n# Overview",
+          body: "prose",
+          position: 0,
+        },
+      ],
+    );
+    const r = await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    expect(r.llmsFullTxt).toContain("## Part one # Overview");
+    // Exactly one H1 per page block: the page title itself.
+    expect(r.llmsFullTxt.match(/^# /gm)?.length).toBe(2); // site header + page
+  });
+
+  it("does not run the section query when no document survives filtering", async () => {
+    const f = fakeSession([
+      { title: "Theirs", url: "https://b.example/y", summary: "page b" },
+    ]);
+    await writeLlmsTxt(
+      { accountId: "acct", siteName: "A", siteOrigin: "https://a.example" },
+      f.deps,
+    );
+    expect(f.queries.some((q) => q.includes("HAS_SECTION"))).toBe(false);
+  });
+});
+
+describe("writeLlmsTxt — refusing an empty full-text file", () => {
+  it("writes llms.txt but not llms-full.txt when no page has full text", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "aeo-"));
+    await writeFile(join(dir, "llms-full.txt"), "PRIOR GOOD FILE", "utf-8");
+    const f = fakeSession([
+      { title: "Thin", url: "https://a.example/t", summary: "only a summary" },
+    ]);
+    const r = await writeLlmsTxt(
+      {
+        accountId: "acct",
+        siteName: "A",
+        siteOrigin: "https://a.example",
+        siteDir: dir,
+      },
+      f.deps,
+    );
+    expect(r.writtenPaths?.index).toBe(join(dir, "llms.txt"));
+    expect(r.writtenPaths?.full).toBeNull();
+    expect(r.fullRefusedReason).toBe("no-full-text-any-page");
+    expect(await readFile(join(dir, "llms-full.txt"), "utf-8")).toBe(
+      "PRIOR GOOD FILE",
+    );
+    expect(existsSync(join(dir, "llms.txt"))).toBe(true);
+  });
+
+  it("writes both files when at least one page has full text", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "aeo-"));
+    const f = fakeSession(
+      [
+        {
+          title: "Thin",
+          url: "https://a.example/t",
+          summary: "only a summary",
+        },
+        { title: "Full", url: "https://a.example/f", summary: "sum" },
+      ],
+      [
+        {
+          url: "https://a.example/f",
+          title: "Body",
+          body: "real prose",
+          position: 0,
+        },
+      ],
+    );
+    const r = await writeLlmsTxt(
+      {
+        accountId: "acct",
+        siteName: "A",
+        siteOrigin: "https://a.example",
+        siteDir: dir,
+      },
+      f.deps,
+    );
+    expect(r.writtenPaths?.full).toBe(join(dir, "llms-full.txt"));
+    expect(r.fullRefusedReason).toBeNull();
+    expect(await readFile(join(dir, "llms-full.txt"), "utf-8")).toContain(
+      "real prose",
+    );
+    expect(r.pagesWithoutFullText).toBe(1);
+  });
+});

package/payload/platform/lib/aeo-llms-txt-writer/src/index.ts

@@ -13,6 +13,13 @@ import type { Session } from "neo4j-driver";
 export interface WriteLlmsTxtInput {
   accountId: string;
   siteName: string;
+  /**
+   * Absolute http(s) origin of the site being generated, e.g.
+   * "https://maxy.institute". Only KnowledgeDocuments whose url starts
+   * with this origin are included. Required: an account publishes many
+   * sites, and an account-wide llms.txt is never correct for any of them.
+   */
+  siteOrigin: string;
   siteDescription?: string;
   siteDir?: string;
 }
@@ -26,8 +33,18 @@ export interface WriteLlmsTxtResult {
   llmsFullTxt: string;
   pageCount: number;
   skippedNoUrl: number;
+  skippedOtherSite: number;
+  pagesWithFullText: number;
+  pagesWithoutFullText: number;
+  sectionCount: number;
   sizeBytes: { index: number; full: number };
-  writtenPaths?: { index: string; full: string };
+  fullRefusedReason: string | null;
+  writtenPaths?: { index: string; full: string | null };
+}
+
+interface SectionRow {
+  title: string;
+  body: string;
 }
 
 interface PageRow {
@@ -35,52 +52,143 @@ interface PageRow {
   url: string;
   summary: string;
   body: string;
+  sections: SectionRow[];
 }
 
-const HEADER_RX = /^#\s/m;
+const HEADER_RX = /^#\s/gm;
 
 function escapeMarkdown(text: string): string {
   return text.replace(/[\[\]\(\)\n\r]/g, " ").trim();
 }
 
+function normaliseOrigin(raw: string): string {
+  let parsed: URL;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    throw new Error(`siteOrigin must be an absolute http(s) URL: ${raw}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`siteOrigin must be an absolute http(s) URL: ${raw}`);
+  }
+  return parsed.origin;
+}
+
+/**
+ * True when `url` is the origin itself or a path beneath it. A bare
+ * startsWith would also admit a different host that merely shares the
+ * origin as a string prefix ("https://a.example" vs "https://a.example.evil"),
+ * which is the cross-site leak this filter exists to stop.
+ */
+function isUnderOrigin(url: string, origin: string): boolean {
+  if (!url.startsWith(origin)) return false;
+  const rest = url.slice(origin.length);
+  return (
+    rest === "" ||
+    rest.startsWith("/") ||
+    rest.startsWith("?") ||
+    rest.startsWith("#")
+  );
+}
+
 function summariseBody(body: string): string {
   const flat = body.replace(/\s+/g, " ").trim();
   if (flat.length <= 200) return flat;
   return flat.slice(0, 197).trimEnd() + "…";
 }
 
+/**
+ * A page's full text. Returns "" when the page carries none of any kind —
+ * the single fact the pagesWithoutFullText counter and the write refusal
+ * are both derived from.
+ */
+function renderFullBody(row: PageRow): string {
+  if (row.sections.length > 0) {
+    return row.sections
+      .map((s) => {
+        const heading = s.title ? `## ${s.title}\n\n` : "";
+        return `${heading}${s.body.replace(HEADER_RX, "## ")}`.trim();
+      })
+      .filter((block) => block.length > 0)
+      .join("\n\n");
+  }
+  if (row.body) return row.body.replace(HEADER_RX, "## ");
+  return "";
+}
+
 export async function writeLlmsTxt(
   input: WriteLlmsTxtInput,
   deps: WriteLlmsTxtDeps,
 ): Promise<WriteLlmsTxtResult> {
+  const origin = normaliseOrigin(input.siteOrigin);
   const session = deps.getSession();
-  let rows: PageRow[] = [];
+  const rows: PageRow[] = [];
   let skippedNoUrl = 0;
+  let skippedOtherSite = 0;
   try {
     const r = await session.run(
       `MATCH (d:KnowledgeDocument {accountId: $accountId})
        RETURN d.title AS title, d.url AS url, d.summary AS summary,
-              coalesce(d.body, d.abstract, '') AS body
+              coalesce(d.body, '') AS body
        ORDER BY d.title ASC`,
       { accountId: input.accountId },
     );
     for (const rec of r.records) {
       const title = (rec.get("title") as string | null) ?? "";
-      const url = (rec.get("url") as string | null) ?? "";
+      const url = ((rec.get("url") as string | null) ?? "").trim();
       const summary = (rec.get("summary") as string | null) ?? "";
       const body = (rec.get("body") as string | null) ?? "";
       if (!url || !title) {
         skippedNoUrl += 1;
         continue;
       }
+      if (!isUnderOrigin(url, origin)) {
+        skippedOtherSite += 1;
+        continue;
+      }
       rows.push({
         title: escapeMarkdown(title),
-        url: url.trim(),
+        url,
         summary:
           escapeMarkdown(summary) || summariseBody(body) || "(no summary)",
         body: body.trim(),
+        sections: [],
       });
     }
+
+    // Second query: the full text. Scoped to the URLs that survived
+    // filtering so no other site's section bodies are ever read. The prose
+    // lives on (:KnowledgeDocument)-[:HAS_SECTION]->(:Section) in `position`
+    // order — see platform/plugins/memory/references/schema-base.md.
+    if (rows.length > 0) {
+      // Keyed to a list, not a single row: two KnowledgeDocuments can carry
+      // the same url, and a plain Map would drop one of them silently and
+      // then report it as having no full text.
+      const byUrl = new Map<string, PageRow[]>();
+      for (const row of rows) {
+        const bucket = byUrl.get(row.url);
+        if (bucket) bucket.push(row);
+        else byUrl.set(row.url, [row]);
+      }
+      const sec = await session.run(
+        `MATCH (d:KnowledgeDocument {accountId: $accountId})-[:HAS_SECTION]->(s:Section)
+         WHERE d.url IN $urls
+         RETURN d.url AS url, s.title AS title,
+                coalesce(s.body, '') AS body,
+                coalesce(s.position, 0) AS position
+         ORDER BY d.url ASC, position ASC`,
+        { accountId: input.accountId, urls: rows.map((row) => row.url) },
+      );
+      for (const rec of sec.records) {
+        const bucket = byUrl.get((rec.get("url") as string) ?? "");
+        if (!bucket) continue;
+        const section: SectionRow = {
+          title: escapeMarkdown((rec.get("title") as string | null) ?? ""),
+          body: ((rec.get("body") as string | null) ?? "").trim(),
+        };
+        for (const row of bucket) row.sections.push(section);
+      }
+    }
   } finally {
     await session.close();
   }
@@ -110,21 +218,23 @@ export async function writeLlmsTxt(
     fullLines.push(`> ${escapeMarkdown(input.siteDescription)}`);
     fullLines.push("");
   }
-  for (const row of rows) {
+  // Render each page's body once. Rendering once is what lets the counters
+  // and the write refusal name the same set of pages.
+  const fullBodies = rows.map((row) => renderFullBody(row));
+  const pagesWithFullText = fullBodies.filter((b) => b.length > 0).length;
+  const pagesWithoutFullText = rows.length - pagesWithFullText;
+  const sectionCount = rows.reduce((n, row) => n + row.sections.length, 0);
+
+  rows.forEach((row, i) => {
     fullLines.push(`# ${row.title}`);
     fullLines.push("");
     fullLines.push(`Source: ${row.url}`);
     fullLines.push("");
-    if (row.body) {
-      const safeBody = row.body.replace(HEADER_RX, "## ");
-      fullLines.push(safeBody);
-    } else {
-      fullLines.push(row.summary);
-    }
+    fullLines.push(fullBodies[i] || row.summary);
     fullLines.push("");
     fullLines.push("---");
     fullLines.push("");
-  }
+  });
   const llmsFullTxt = fullLines.join("\n");
 
   const sizeBytes = {
@@ -133,10 +243,23 @@ export async function writeLlmsTxt(
   };
 
   process.stderr.write(
-    `[aeo-llms-txt] site=${input.siteName} pages=${rows.length} skippedNoUrl=${skippedNoUrl} indexBytes=${sizeBytes.index} fullBytes=${sizeBytes.full}\n`,
+    `[aeo-llms-txt] site=${input.siteName} origin=${origin} pages=${rows.length} skippedNoUrl=${skippedNoUrl} skippedOtherSite=${skippedOtherSite} pagesWithFullText=${pagesWithFullText} pagesWithoutFullText=${pagesWithoutFullText} sections=${sectionCount} indexBytes=${sizeBytes.index} fullBytes=${sizeBytes.full}\n`,
   );
 
-  let writtenPaths: { index: string; full: string } | undefined;
+  if (pagesWithoutFullText > 0) {
+    const missing = rows
+      .filter((_, i) => fullBodies[i].length === 0)
+      .map((row) => row.url);
+    const shown = missing.slice(0, 20);
+    process.stderr.write(
+      `[aeo-llms-txt] WARN op=full-text-missing pages=${missing.length} shown=${shown.length} urls=[${shown.join(" ")}]\n`,
+    );
+  }
+
+  const fullRefusedReason =
+    pagesWithFullText === 0 ? "no-full-text-any-page" : null;
+
+  let writtenPaths: { index: string; full: string | null } | undefined;
   if (input.siteDir) {
     const dir = resolvePath(input.siteDir);
     let dirStat;
@@ -152,12 +275,21 @@ export async function writeLlmsTxt(
       throw new Error(`siteDir is not a directory: ${dir}`);
     }
     const indexPath = resolvePath(dir, "llms.txt");
-    const fullPath = resolvePath(dir, "llms-full.txt");
     await writeFile(indexPath, llmsTxt, "utf-8");
-    await writeFile(fullPath, llmsFullTxt, "utf-8");
+    let fullPath: string | null = null;
+    if (fullRefusedReason) {
+      // A full-text file with no full text in it is worse than a stale
+      // one: it silently replaces real prose with the index's summaries.
+      process.stderr.write(
+        `[aeo-llms-txt] refuse op=write-full reason=${fullRefusedReason} site=${dir}\n`,
+      );
+    } else {
+      fullPath = resolvePath(dir, "llms-full.txt");
+      await writeFile(fullPath, llmsFullTxt, "utf-8");
+    }
     writtenPaths = { index: indexPath, full: fullPath };
     process.stderr.write(
-      `[aeo-llms-txt] wrote site=${dir} indexBytes=${sizeBytes.index} fullBytes=${sizeBytes.full}\n`,
+      `[aeo-llms-txt] wrote site=${dir} indexBytes=${sizeBytes.index} fullBytes=${fullPath ? sizeBytes.full : 0}\n`,
     );
   }
 
@@ -166,7 +298,12 @@ export async function writeLlmsTxt(
     llmsFullTxt,
     pageCount: rows.length,
     skippedNoUrl,
+    skippedOtherSite,
+    pagesWithFullText,
+    pagesWithoutFullText,
+    sectionCount,
     sizeBytes,
+    fullRefusedReason,
     writtenPaths,
   };
 }

package/payload/platform/lib/aeo-llms-txt-writer/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    setupFiles: ["../../test/tmpdir-setup.ts"],
+    environment: "node",
+    globals: false,
+    include: ["src/__tests__/**/*.test.ts"],
+  },
+});