@warpgogol/werkstatt-shared 0.14.0 → 0.14.1

package/src/share/semantic/tests/feed.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import { buildJsonFeed, buildRssFeed } from "../feed.ts";
+
+const channel = {
+  title: "Test Feed",
+  url: "https://example.com",
+  description: "A test feed",
+  language: "de",
+  selfUrl: "https://example.com/feed.xml",
+};
+
+const items = [
+  { title: "Item 1", url: "https://example.com/1", summary: "Summary 1", publishedAt: "2024-01-01" },
+  { title: "Item 2", url: "https://example.com/2", summary: "Summary 2", publishedAt: "2024-06-01" },
+];
+
+describe("buildRssFeed", () => {
+  it("produces valid RSS XML", () => {
+    const result = buildRssFeed(channel, items);
+    expect(result).toContain('<?xml version="1.0"');
+    expect(result).toContain("<rss version=\"2.0\"");
+    expect(result).toContain("<channel>");
+    expect(result).toContain("<title>Test Feed</title>");
+    expect(result).toContain("<language>de</language>");
+  });
+
+  it("sorts items by publishedAt descending", () => {
+    const result = buildRssFeed(channel, items);
+    const item1Idx = result.indexOf("Item 1");
+    const item2Idx = result.indexOf("Item 2");
+    expect(item2Idx).toBeLessThan(item1Idx);
+  });
+
+  it("escapes XML special characters", () => {
+    const result = buildRssFeed(channel, [
+      { title: "A & B <C>", url: "https://example.com/x", summary: "S", publishedAt: "2024-01-01" },
+    ]);
+    expect(result).toContain("A &amp; B &lt;C&gt;");
+  });
+
+  it("includes atom self link", () => {
+    const result = buildRssFeed(channel, items);
+    expect(result).toContain('href="https://example.com/feed.xml"');
+    expect(result).toContain('rel="self"');
+  });
+
+  it("derives lastBuildDate from latest item", () => {
+    const result = buildRssFeed(channel, items);
+    expect(result).toContain("<lastBuildDate>");
+  });
+
+  it("omits lastBuildDate for empty feed", () => {
+    const result = buildRssFeed(channel, []);
+    expect(result).not.toContain("<lastBuildDate>");
+  });
+});
+
+describe("buildJsonFeed", () => {
+  it("produces JSON Feed v1.1", () => {
+    const result = buildJsonFeed({
+      title: "Test Feed",
+      home_page_url: "https://example.com",
+      feed_url: "https://example.com/feed.json",
+      description: "A test feed",
+      language: "de",
+      items,
+    });
+    const parsed = JSON.parse(result);
+    expect(parsed.version).toBe("https://jsonfeed.org/version/1.1");
+    expect(parsed.title).toBe("Test Feed");
+    expect(parsed.items).toHaveLength(2);
+  });
+
+  it("sorts items by publishedAt descending", () => {
+    const result = buildJsonFeed({
+      title: "Test",
+      home_page_url: "https://example.com",
+      feed_url: "https://example.com/feed.json",
+      description: "",
+      language: "de",
+      items,
+    });
+    const parsed = JSON.parse(result);
+    expect(parsed.items[0].title).toBe("Item 2");
+    expect(parsed.items[1].title).toBe("Item 1");
+  });
+
+  it("includes date_modified when updatedAt provided", () => {
+    const result = buildJsonFeed({
+      title: "Test",
+      home_page_url: "https://example.com",
+      feed_url: "https://example.com/feed.json",
+      description: "",
+      language: "de",
+      items: [{ title: "T", url: "https://example.com/1", summary: "S", publishedAt: "2024-01-01", updatedAt: "2024-06-01" }],
+    });
+    const parsed = JSON.parse(result);
+    expect(parsed.items[0].date_modified).toBe("2024-06-01");
+  });
+
+  it("omits items array for empty feed", () => {
+    const result = buildJsonFeed({
+      title: "Test",
+      home_page_url: "https://example.com",
+      feed_url: "https://example.com/feed.json",
+      description: "",
+      language: "de",
+      items: [],
+    });
+    const parsed = JSON.parse(result);
+    expect(parsed.items).toBeUndefined();
+  });
+});

package/src/share/semantic/tests/helpers.ts

@@ -0,0 +1,32 @@
+import type { SemanticOrganization, SemanticPageModel, SemanticPageType } from "../models.ts";
+
+export function makeOrganization(
+  overrides: Partial<SemanticOrganization> = {},
+): SemanticOrganization {
+  return {
+    name: "Warpgogol",
+    description: "Digital infrastructure for nonprofits",
+    url: "https://example.com",
+    ...overrides,
+  };
+}
+
+export function makePage(
+  overrides: Partial<SemanticPageModel> & { type?: SemanticPageType } = {},
+): SemanticPageModel {
+  return {
+    type: overrides.type ?? "content",
+    lang: "de",
+    url: "https://example.com/de/page/",
+    title: "Test Page",
+    description: "A test page description",
+    heading: "Test Heading",
+    breadcrumbs: [
+      { name: "Home", url: "https://example.com/de/" },
+      { name: "Test Page", url: "https://example.com/de/page/" },
+    ],
+    blocks: [],
+    organization: makeOrganization(),
+    ...overrides,
+  };
+}

package/src/share/semantic/tests/ids.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import {
+  canonicalRootUrl,
+  createSemanticIds,
+  getBaseUrl,
+  markdownTwinRelPath,
+  markdownTwinUrlPath,
+  toAbsoluteUrl,
+  toCanonicalUrl,
+  toPathname,
+} from "../ids.ts";
+
+describe("getBaseUrl", () => {
+  it("returns origin from string URL", () => {
+    expect(getBaseUrl("https://example.com/de/page")).toBe("https://example.com");
+  });
+
+  it("returns origin from URL object", () => {
+    expect(getBaseUrl(new URL("https://example.com/de/page?q=1"))).toBe("https://example.com");
+  });
+});
+
+describe("toCanonicalUrl", () => {
+  it("strips search and hash", () => {
+    expect(toCanonicalUrl("https://example.com/de/page?q=1#top")).toBe(
+      "https://example.com/de/page",
+    );
+  });
+});
+
+describe("toAbsoluteUrl", () => {
+  it("resolves relative path against base", () => {
+    expect(toAbsoluteUrl("https://example.com", "/de/page")).toBe("https://example.com/de/page");
+  });
+});
+
+describe("canonicalRootUrl", () => {
+  it("returns unprefixed root URL", () => {
+    expect(canonicalRootUrl("https://example.com")).toBe("https://example.com/");
+  });
+});
+
+describe("toPathname", () => {
+  it("extracts pathname from URL string", () => {
+    expect(toPathname("https://example.com/de/page?q=1")).toBe("/de/page");
+  });
+});
+
+describe("markdownTwinRelPath", () => {
+  const opts = { supportedLangs: ["de", "uk"] };
+
+  it("returns index.md for root path", () => {
+    expect(markdownTwinRelPath("/", opts)).toBe("index.md");
+  });
+
+  it("returns lang-root index for language root", () => {
+    expect(markdownTwinRelPath("/de/", opts)).toBe("de/index.md");
+  });
+
+  it("returns nested path as .md file", () => {
+    expect(markdownTwinRelPath("/de/about/", opts)).toBe("de/about.md");
+  });
+});
+
+describe("markdownTwinUrlPath", () => {
+  it("prefixes rel path with slash", () => {
+    expect(markdownTwinUrlPath("/de/about/", { supportedLangs: ["de"] })).toBe("/de/about.md");
+  });
+});
+
+describe("createSemanticIds", () => {
+  const ids = createSemanticIds("https://example.com");
+
+  it("generates organization id", () => {
+    expect(ids.organization).toBe("https://example.com/#/schema/organization");
+  });
+
+  it("generates website id", () => {
+    expect(ids.website).toBe("https://example.com/#/schema/website");
+  });
+
+  it("generates webpage id from page URL", () => {
+    expect(ids.webpage("https://example.com/de/page")).toBe(
+      "https://example.com/de/page#/schema/webpage",
+    );
+  });
+
+  it("generates breadcrumb id from page URL", () => {
+    expect(ids.breadcrumb("https://example.com/de/page")).toBe(
+      "https://example.com/de/page#/schema/breadcrumb",
+    );
+  });
+
+  it("generates person id with slugified name", () => {
+    expect(ids.person("Jane Doe")).toBe("https://example.com/#/schema/person/jane-doe");
+  });
+
+  it("generates initiative id with slugified name", () => {
+    expect(ids.initiative("Project Alpha")).toBe(
+      "https://example.com/#/schema/initiative/project-alpha",
+    );
+  });
+
+  it("generates service id with slugified name", () => {
+    expect(ids.service("Web Hosting")).toBe("https://example.com/#/schema/service/web-hosting");
+  });
+
+  it("generates faq id from page URL", () => {
+    expect(ids.faq("https://example.com/de/page")).toBe(
+      "https://example.com/de/page#/schema/faq",
+    );
+  });
+
+  it("strips trailing slash from baseUrl", () => {
+    const ids2 = createSemanticIds("https://example.com/");
+    expect(ids2.organization).toBe("https://example.com/#/schema/organization");
+  });
+});

package/src/share/semantic/tests/image-sitemap.test.ts

@@ -0,0 +1,109 @@
+import { describe, expect, it } from "vitest";
+import {
+  generateImageSitemapXml,
+  harvestContentImage,
+  isHtmlRedirectPage,
+  isSyntheticPreviewUrl,
+} from "../image-sitemap.ts";
+
+describe("isHtmlRedirectPage", () => {
+  it("detects meta-refresh redirect", () => {
+    expect(isHtmlRedirectPage('<meta http-equiv="refresh" content="0;url=/de/">')).toBe(true);
+  });
+
+  it("returns false for normal pages", () => {
+    expect(isHtmlRedirectPage("<html><body>Hello</body></html>")).toBe(false);
+  });
+});
+
+describe("isSyntheticPreviewUrl", () => {
+  it("detects preview screenshots", () => {
+    expect(isSyntheticPreviewUrl("https://example.com/preview/page.png")).toBe(true);
+  });
+
+  it("detects og-image fallback", () => {
+    expect(isSyntheticPreviewUrl("https://example.com/og-image.png")).toBe(true);
+  });
+
+  it("returns false for content images", () => {
+    expect(isSyntheticPreviewUrl("https://example.com/_astro/img.jpg")).toBe(false);
+  });
+});
+
+describe("harvestContentImage", () => {
+  it("extracts canonical URL from link tag", () => {
+    const html = '<link rel="canonical" href="https://example.com/de/page" />';
+    const result = harvestContentImage(html, "https://example.com");
+    expect(result.loc).toBe("https://example.com/de/page");
+  });
+
+  it("returns null loc when no canonical", () => {
+    const result = harvestContentImage("<html></html>", "https://example.com");
+    expect(result.loc).toBeNull();
+  });
+
+  it("harvests img with data-content-image attribute", () => {
+    const html = '<img src="/_astro/hero.jpg" data-content-image alt="Hero" />';
+    const result = harvestContentImage(html, "https://example.com");
+    expect(result.imageUrls).toContain("https://example.com/_astro/hero.jpg");
+    expect(result.title).toBe("Hero");
+  });
+
+  it("harvests meta x-content-image", () => {
+    const html = '<meta name="x-content-image" content="https://example.com/img.jpg" />';
+    const result = harvestContentImage(html, "https://example.com");
+    expect(result.imageUrls).toContain("https://example.com/img.jpg");
+  });
+
+  it("excludes synthetic preview URLs", () => {
+    const html = '<img src="/og-image.png" data-content-image alt="OG" />';
+    const result = harvestContentImage(html, "https://example.com");
+    expect(result.imageUrls).toHaveLength(0);
+  });
+
+  it("deduplicates identical URLs", () => {
+    const html = `
+      <img src="/img.jpg" data-content-image alt="A" />
+      <meta name="x-content-image" content="/img.jpg" />
+    `;
+    const result = harvestContentImage(html, "https://example.com");
+    expect(result.imageUrls).toHaveLength(1);
+  });
+
+  it("falls back to og:image:alt for title", () => {
+    const html = `
+      <img src="/img.jpg" data-content-image />
+      <meta property="og:image:alt" content="OG Alt" />
+    `;
+    const result = harvestContentImage(html, "https://example.com");
+    expect(result.title).toBe("OG Alt");
+  });
+});
+
+describe("generateImageSitemapXml", () => {
+  it("produces valid image sitemap XML", () => {
+    const result = generateImageSitemapXml([
+      { loc: "https://example.com/page", imageUrl: "https://example.com/img.jpg", title: "Test" },
+    ]);
+    expect(result).toContain('<?xml version="1.0"');
+    expect(result).toContain("<urlset");
+    expect(result).toContain("xmlns:image=");
+    expect(result).toContain("<loc>https://example.com/page</loc>");
+    expect(result).toContain("<image:loc>https://example.com/img.jpg</image:loc>");
+    expect(result).toContain("<image:title>Test</image:title>");
+  });
+
+  it("produces empty urlset for no entries", () => {
+    const result = generateImageSitemapXml([]);
+    expect(result).toContain("<urlset");
+    expect(result).not.toContain("<url>");
+  });
+
+  it("escapes XML in URLs", () => {
+    const result = generateImageSitemapXml([
+      { loc: "https://example.com/a&b", imageUrl: "https://example.com/<img>" },
+    ]);
+    expect(result).toContain("a&amp;b");
+    expect(result).toContain("&lt;img&gt;");
+  });
+});

package/src/share/semantic/tests/jsonld.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { buildJsonLd } from "../jsonld.ts";
+import { makePage } from "./helpers.ts";
+
+describe("buildJsonLd", () => {
+  it("produces a valid JSON-LD document with @context and @graph", () => {
+    const page = makePage();
+    const doc = buildJsonLd(page);
+    expect(doc["@context"]).toBe("https://schema.org");
+    expect(Array.isArray(doc["@graph"])).toBe(true);
+    expect(doc["@graph"].length).toBeGreaterThan(0);
+  });
+
+  it("includes Organization and WebSite nodes in graph", () => {
+    const page = makePage();
+    const doc = buildJsonLd(page);
+    const types = doc["@graph"].map((n) => n["@type"]);
+    expect(types.some((t) => Array.isArray(t) && t.includes("Organization"))).toBe(true);
+    expect(types.some((t) => t === "WebSite" || (Array.isArray(t) && t.includes("WebSite")))).toBe(
+      true,
+    );
+  });
+
+  it("includes WebPage node in graph", () => {
+    const page = makePage();
+    const doc = buildJsonLd(page);
+    const types = doc["@graph"].map((n) => n["@type"]);
+    expect(types.some((t) => Array.isArray(t) && t.includes("WebPage"))).toBe(true);
+  });
+
+  it("deduplicates graph nodes by @id", () => {
+    const page = makePage();
+    const doc = buildJsonLd(page);
+    const ids = doc["@graph"].map((n) => n["@id"]).filter(Boolean);
+    const uniqueIds = new Set(ids);
+    expect(ids.length).toBe(uniqueIds.size);
+  });
+
+  it("includes BreadcrumbList when breadcrumbs > 1", () => {
+    const page = makePage({
+      breadcrumbs: [
+        { name: "Home", url: "https://example.com/de/" },
+        { name: "About", url: "https://example.com/de/about/" },
+      ],
+    });
+    const doc = buildJsonLd(page);
+    const types = doc["@graph"].map((n) => n["@type"]);
+    expect(types).toContain("BreadcrumbList");
+  });
+
+  it("includes extraGraphNodes when provided", () => {
+    const page = makePage({
+      extraGraphNodes: [
+        { "@type": "SoftwareApplication", "@id": "https://example.com/#/schema/app", name: "App" },
+      ],
+    });
+    const doc = buildJsonLd(page);
+    const ids = doc["@graph"].map((n) => n["@id"]);
+    expect(ids).toContain("https://example.com/#/schema/app");
+  });
+});

package/src/share/semantic/tests/llms-policy.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import { LLMS_DEPTH_BY_SEMANTIC_TYPE, resolveLlmsPolicy } from "../llms-policy.ts";
+
+describe("resolveLlmsPolicy", () => {
+  it("returns full depth by default", () => {
+    expect(resolveLlmsPolicy(undefined, "content")).toEqual({ depth: "full" });
+  });
+
+  it("uses type default for openSource", () => {
+    expect(resolveLlmsPolicy(undefined, "openSource")).toEqual({ depth: "index-only" });
+  });
+
+  it("uses type default for legal", () => {
+    expect(resolveLlmsPolicy(undefined, "legal")).toEqual({ depth: "exclude" });
+  });
+
+  it("accepts string shorthand", () => {
+    expect(resolveLlmsPolicy("summary", "content")).toEqual({ depth: "summary" });
+  });
+
+  it("falls back to type default for invalid string depth", () => {
+    expect(resolveLlmsPolicy("invalid" as never, "openSource")).toEqual({ depth: "index-only" });
+  });
+
+  it("accepts object form with valid depth", () => {
+    expect(resolveLlmsPolicy({ depth: "exclude" }, "content")).toEqual({ depth: "exclude" });
+  });
+
+  it("includes section excludes when provided", () => {
+    const result = resolveLlmsPolicy(
+      { depth: "summary", sections: { exclude: ["s1", "s2"] } },
+      "content",
+    );
+    expect(result.depth).toBe("summary");
+    expect(result.sections?.exclude).toEqual(["s1", "s2"]);
+  });
+
+  it("filters empty section exclude ids", () => {
+    const result = resolveLlmsPolicy(
+      { depth: "summary", sections: { exclude: ["s1", ""] } },
+      "content",
+    );
+    expect(result.sections?.exclude).toEqual(["s1"]);
+  });
+
+  it("omits sections when no valid excludes", () => {
+    const result = resolveLlmsPolicy({ depth: "summary", sections: { exclude: [] } }, "content");
+    expect(result.sections).toBeUndefined();
+  });
+});
+
+describe("LLMS_DEPTH_BY_SEMANTIC_TYPE", () => {
+  it("maps openSource to index-only", () => {
+    expect(LLMS_DEPTH_BY_SEMANTIC_TYPE.openSource).toBe("index-only");
+  });
+
+  it("maps legal to exclude", () => {
+    expect(LLMS_DEPTH_BY_SEMANTIC_TYPE.legal).toBe("exclude");
+  });
+});

package/src/share/semantic/tests/llms.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import { buildLlmsFull, buildLlmsIndex } from "../llms.ts";
+import { makePage } from "./helpers.ts";
+import type { SemanticSiteModel } from "../models.ts";
+
+function makeSite(overrides: Partial<SemanticSiteModel> = {}): SemanticSiteModel {
+  const page = makePage();
+  return {
+    organization: page.organization,
+    baseUrl: "https://example.com",
+    defaultLanguage: "de",
+    lang: "de",
+    pages: [page],
+    ...overrides,
+  };
+}
+
+describe("buildLlmsIndex", () => {
+  it("produces llms.txt with site name and description", () => {
+    const site = makeSite();
+    const result = buildLlmsIndex(site);
+    expect(result).toContain("# Warpgogol");
+    expect(result).toContain("Digital infrastructure for nonprofits");
+    expect(result).toContain("## Primary sources");
+  });
+
+  it("includes llms-full.txt reference", () => {
+    const site = makeSite();
+    const result = buildLlmsIndex(site);
+    expect(result).toContain("llms-full.txt");
+  });
+
+  it("includes page links with absolute URLs", () => {
+    const site = makeSite();
+    const result = buildLlmsIndex(site);
+    expect(result).toContain("https://example.com");
+  });
+
+  it("filters out excluded pages from index", () => {
+    const page = makePage({
+      output: {
+        sitemap: { include: true, category: "content", includeLastmod: true },
+        llms: { depth: "exclude" },
+        robots: { index: true, follow: true },
+      },
+    });
+    const site = makeSite({ pages: [page] });
+    const result = buildLlmsIndex(site);
+    expect(result).not.toContain("Test Page");
+  });
+
+  it("includes agent discovery links when agent.enabled is not false", () => {
+    const site = makeSite();
+    const result = buildLlmsIndex(site);
+    expect(result).toContain("agent.json");
+  });
+
+  it("omits agent discovery links when agent.enabled is false", () => {
+    const site = makeSite({ agent: { enabled: false } } as never);
+    const result = buildLlmsIndex(site);
+    expect(result).not.toContain("agent.json");
+  });
+
+  it("includes organization facts section", () => {
+    const site = makeSite();
+    const result = buildLlmsIndex(site);
+    expect(result).toContain("## Organization");
+  });
+});
+
+describe("buildLlmsFull", () => {
+  it("produces llms-full.txt with site name and description", () => {
+    const site = makeSite();
+    const result = buildLlmsFull(site);
+    expect(result).toContain("# Warpgogol");
+    expect(result).toContain("Digital infrastructure for nonprofits");
+  });
+
+  it("includes page sections for full depth pages", () => {
+    const site = makeSite();
+    const result = buildLlmsFull(site);
+    expect(result).toContain("## Test Heading");
+  });
+
+  it("includes page header but not body for summary depth", () => {
+    const page = makePage({
+      output: {
+        sitemap: { include: true, category: "content", includeLastmod: true },
+        llms: { depth: "summary" },
+        robots: { index: true, follow: true },
+      },
+    });
+    const site = makeSite({ pages: [page] });
+    const result = buildLlmsFull(site);
+    expect(result).toContain("## Test Heading");
+    expect(result).toContain("URL:");
+    expect(result).toContain("Description:");
+  });
+
+  it("filters out excluded pages", () => {
+    const page = makePage({
+      output: {
+        sitemap: { include: true, category: "content", includeLastmod: true },
+        llms: { depth: "exclude" },
+        robots: { index: true, follow: true },
+      },
+    });
+    const site = makeSite({ pages: [page] });
+    const result = buildLlmsFull(site);
+    expect(result).not.toContain("## Test Page");
+  });
+
+  it("includes organization facts section", () => {
+    const site = makeSite();
+    const result = buildLlmsFull(site);
+    expect(result).toContain("## Organization facts");
+  });
+});

package/src/share/semantic/tests/markdown-hygiene.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import {
+  canonicalizeGeneratedMarkdownText,
+  formatGeneratedMarkdownListItem,
+  normalizeGeneratedMarkdownText,
+} from "../markdown-hygiene.ts";
+
+describe("normalizeGeneratedMarkdownText", () => {
+  it("returns empty string for undefined", () => {
+    expect(normalizeGeneratedMarkdownText(undefined)).toBe("");
+  });
+
+  it("normalizes CRLF to LF", () => {
+    expect(normalizeGeneratedMarkdownText("a\r\nb")).toBe("a\nb");
+  });
+
+  it("converts <br> tags to newlines", () => {
+    expect(normalizeGeneratedMarkdownText("a<br>b")).toBe("a\nb");
+    expect(normalizeGeneratedMarkdownText("a<br/>b")).toBe("a\nb");
+  });
+
+  it("converts date slashes to ISO format", () => {
+    expect(normalizeGeneratedMarkdownText("2024/1/5")).toBe("2024-01-05");
+    expect(normalizeGeneratedMarkdownText("2024/12/15")).toBe("2024-12-15");
+  });
+
+  it("fixes - --- to ---", () => {
+    expect(normalizeGeneratedMarkdownText("- ---\n")).toBe("---");
+  });
+
+  it("fixes - - to - ", () => {
+    expect(normalizeGeneratedMarkdownText("- - item")).toBe("- item");
+  });
+
+  it("fixes - # to #", () => {
+    expect(normalizeGeneratedMarkdownText("- ## Heading")).toBe("## Heading");
+  });
+
+  it("trims trailing whitespace", () => {
+    expect(normalizeGeneratedMarkdownText("text   \n")).toBe("text");
+  });
+});
+
+describe("canonicalizeGeneratedMarkdownText", () => {
+  it("strips default language prefix from URLs", () => {
+    const result = canonicalizeGeneratedMarkdownText("Link to [page](https://example.com/de/page)", {
+      baseUrl: "https://example.com",
+      defaultLanguage: "de",
+    });
+    expect(result).toBe("Link to [page](https://example.com/page)");
+  });
+
+  it("does not strip when no baseUrl/defaultLanguage", () => {
+    const result = canonicalizeGeneratedMarkdownText("https://example.com/de/page");
+    expect(result).toBe("https://example.com/de/page");
+  });
+});
+
+describe("formatGeneratedMarkdownListItem", () => {
+  it("wraps plain text as list item", () => {
+    expect(formatGeneratedMarkdownListItem("Simple text")).toEqual(["- Simple text"]);
+  });
+
+  it("returns empty array for empty text", () => {
+    expect(formatGeneratedMarkdownListItem("")).toEqual([]);
+  });
+
+  it("splits markdown blocks into lines", () => {
+    const result = formatGeneratedMarkdownListItem("## Heading\n\nParagraph");
+    expect(result).toEqual(["## Heading", "", "Paragraph"]);
+  });
+});