@warpgogol/werkstatt-shared 0.14.0 → 0.15.0

package/src/semantic/tests/organization-profile.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import { buildOrganizationProfile } from "../organization-profile.ts";
+
+const baseInput = {
+  lang: "de",
+  siteUrl: "https://example.com",
+  brandName: "Warpgogol",
+  description: "Digital infrastructure",
+  founders: [],
+  boardMembers: [],
+};
+
+describe("buildOrganizationProfile", () => {
+  it("builds organization with canonical root URL", () => {
+    const result = buildOrganizationProfile(baseInput);
+    expect(result.organization.name).toBe("Warpgogol");
+    expect(result.organization.url).toBe("https://example.com/");
+    expect(result.organization.description).toBe("Digital infrastructure");
+  });
+
+  it("emits image as og-image.png absolute URL", () => {
+    const result = buildOrganizationProfile(baseInput);
+    expect(result.organization.image).toBe("https://example.com/og-image.png");
+  });
+
+  it("deduplicates people by name", () => {
+    const result = buildOrganizationProfile({
+      ...baseInput,
+      founders: [{ name: "Jane" }, { name: "John" }],
+      boardMembers: [{ name: "Jane" }, { name: "Bob" }],
+    });
+    expect(result.people.map((p) => p.name).sort()).toEqual(["Bob", "Jane", "John"]);
+  });
+
+  it("prefers team over founders+board when available", () => {
+    const result = buildOrganizationProfile({
+      ...baseInput,
+      founders: [{ name: "Founder" }],
+      boardMembers: [{ name: "Board" }],
+      team: [{ name: "Team Member" }],
+    });
+    expect(result.people).toHaveLength(1);
+    expect(result.people[0].name).toBe("Team Member");
+  });
+
+  it("builds address from primitives", () => {
+    const result = buildOrganizationProfile({
+      ...baseInput,
+      address: { street: "Test St", streetNumber: "1", zip: "12345", city: "Berlin", country: "DE" },
+    });
+    expect(result.organization.address).toEqual({
+      streetAddress: "Test St 1",
+      postalCode: "12345",
+      addressLocality: "Berlin",
+      addressCountry: "DE",
+    });
+  });
+
+  it("emits contactPoints when email or contactType provided", () => {
+    const result = buildOrganizationProfile({
+      ...baseInput,
+      email: "info@example.com",
+      contactType: "support",
+    });
+    expect(result.organization.contactPoints).toEqual([
+      { contactType: "support", email: "info@example.com" },
+    ]);
+  });
+
+  it("emits donationAccount from bank primitives", () => {
+    const result = buildOrganizationProfile({
+      ...baseInput,
+      bank: { accountHolder: "Org", iban: "DE00", bic: "BIC", bankName: "Bank", konto: "1", blz: "2" },
+    });
+    expect(result.organization.donationAccount).toEqual({
+      accountHolder: "Org",
+      iban: "DE00",
+      bic: "BIC",
+      bankName: "Bank",
+      accountNumber: "1",
+      bankCode: "2",
+    });
+  });
+
+  it("emits sameAs and logo when provided", () => {
+    const result = buildOrganizationProfile({
+      ...baseInput,
+      sameAs: ["https://twitter.com/example"],
+      logoUrl: "https://example.com/logo.png",
+    });
+    expect(result.organization.sameAs).toEqual(["https://twitter.com/example"]);
+    expect(result.organization.logo).toBe("https://example.com/logo.png");
+  });
+
+  it("emits schemaType override", () => {
+    const result = buildOrganizationProfile({
+      ...baseInput,
+      schemaType: ["Organization", "ProfessionalService"],
+    });
+    expect(result.organization.schemaType).toEqual(["Organization", "ProfessionalService"]);
+  });
+
+  it("returns empty initiatives array", () => {
+    const result = buildOrganizationProfile(baseInput);
+    expect(result.initiatives).toEqual([]);
+  });
+});

package/src/{share/tests/output-projection.test.ts → semantic/tests/output-projection-0143.test.ts}

@@ -6,7 +6,7 @@
 */
 
 import { test, expect } from "vitest";
-import { resolvePageOutput } from "../semantic/output-projection.ts";
+import { resolvePageOutput } from "../output-projection.ts";
 
 test("content defaults apply when no semanticType is given", () => {
   const result = resolvePageOutput(undefined, {});

package/src/semantic/tests/output-projection.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { resolvePageOutput } from "../output-projection.ts";
+
+describe("resolvePageOutput", () => {
+  it("returns defaults for undefined input", () => {
+    const result = resolvePageOutput(undefined);
+    expect(result.sitemap.include).toBe(true);
+    expect(result.sitemap.category).toBe("content");
+    expect(result.sitemap.includeLastmod).toBe(true);
+    expect(result.robots.index).toBe(true);
+    expect(result.robots.follow).toBe(true);
+    expect(result.llms.depth).toBe("full");
+  });
+
+  it("handles sitemap: false boolean shorthand", () => {
+    const result = resolvePageOutput({ sitemap: false });
+    expect(result.sitemap.include).toBe(false);
+  });
+
+  it("handles sitemap object form", () => {
+    const result = resolvePageOutput({
+      sitemap: { include: false, category: "custom", lastmod: "2024-01-01", includeLastmod: false },
+    });
+    expect(result.sitemap.include).toBe(false);
+    expect(result.sitemap.category).toBe("custom");
+    expect(result.sitemap.lastmod).toBe("2024-01-01");
+    expect(result.sitemap.includeLastmod).toBe(false);
+  });
+
+  it("uses legal category for legal semanticType", () => {
+    const result = resolvePageOutput({}, { semanticType: "legal" });
+    expect(result.sitemap.category).toBe("legal");
+  });
+
+  it("handles robots: false boolean shorthand", () => {
+    const result = resolvePageOutput({ robots: false });
+    expect(result.robots.index).toBe(false);
+    expect(result.robots.follow).toBe(false);
+  });
+
+  it("handles robots object form", () => {
+    const result = resolvePageOutput({ robots: { index: false, follow: true } });
+    expect(result.robots.index).toBe(false);
+    expect(result.robots.follow).toBe(true);
+  });
+
+  it("handles llms string shorthand", () => {
+    const result = resolvePageOutput({ llms: "index-only" });
+    expect(result.llms.depth).toBe("index-only");
+  });
+
+  it("handles llms object form with sections", () => {
+    const result = resolvePageOutput({
+      llms: { depth: "summary", sections: { exclude: ["section-1", "section-2"] } },
+    });
+    expect(result.llms.depth).toBe("summary");
+    expect(result.llms.sections?.exclude).toEqual(["section-1", "section-2"]);
+  });
+
+  it("resolves content image", () => {
+    const result = resolvePageOutput({
+      image: { url: "https://example.com/img.jpg", alt: "Test", width: 800, height: 600 },
+    });
+    expect(result.image).toEqual({
+      url: "https://example.com/img.jpg",
+      alt: "Test",
+      width: 800,
+      height: 600,
+      contentImage: true,
+    });
+  });
+
+  it("omits image when url is empty", () => {
+    const result = resolvePageOutput({ image: { url: "" } });
+    expect(result.image).toBeUndefined();
+  });
+});

package/src/semantic/tests/page-markdown.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import { buildPageMarkdown } from "../page-markdown.ts";
+import { makePage } from "./helpers.ts";
+
+describe("buildPageMarkdown", () => {
+  it("produces markdown with page title as h1", () => {
+    const page = makePage({ title: "Test Page" });
+    const result = buildPageMarkdown(page);
+    expect(result).toContain("# Test Page");
+  });
+
+  it("includes Summary section from lead", () => {
+    const page = makePage({ lead: "This is the lead text." });
+    const result = buildPageMarkdown(page);
+    expect(result).toContain("## Summary");
+    expect(result).toContain("This is the lead text.");
+  });
+
+  it("falls back to description for summary", () => {
+    const page = makePage({ description: "A test page description" });
+    const result = buildPageMarkdown(page);
+    expect(result).toContain("## Summary");
+    expect(result).toContain("A test page description");
+  });
+
+  it("includes Business context section for generic blocks", () => {
+    const page = makePage({
+      blocks: [
+        {
+          id: "block-1",
+          blockType: "prose",
+          heading: "About Us",
+          summary: "We are great.",
+        },
+      ],
+    });
+    const result = buildPageMarkdown(page);
+    expect(result).toContain("## Business context");
+    expect(result).toContain("### About Us");
+    expect(result).toContain("We are great.");
+  });
+
+  it("classifies legal blocks as Constraints", () => {
+    const page = makePage({
+      blocks: [
+        {
+          id: "block-1",
+          blockType: "prose",
+          heading: "Legal Notice",
+          summary: "Legal info.",
+        },
+      ],
+    });
+    const result = buildPageMarkdown(page);
+    expect(result).toContain("## Constraints");
+    expect(result).toContain("### Legal Notice");
+  });
+
+  it("includes People section when page has people", () => {
+    const page = makePage({
+      people: [{ name: "Jane Doe", role: "CEO", description: "Leader" }],
+    });
+    const result = buildPageMarkdown(page);
+    expect(result).toContain("## People");
+    expect(result).toContain("### Jane Doe");
+    expect(result).toContain("**CEO**");
+  });
+
+  it("includes Initiatives section when page has initiatives", () => {
+    const page = makePage({
+      initiatives: [{ id: "init-1", name: "Project Alpha", summary: "A project" }],
+    });
+    const result = buildPageMarkdown(page);
+    expect(result).toContain("## Initiatives");
+    expect(result).toContain("Project Alpha");
+  });
+
+  it("includes FAQ section when page has faqEntries", () => {
+    const page = makePage({
+      faqEntries: [{ id: "q1", question: "What is this?", answer: "A test." }],
+    });
+    const result = buildPageMarkdown(page);
+    expect(result).toContain("## FAQ");
+    expect(result).toContain("### What is this?");
+    expect(result).toContain("A test.");
+  });
+
+  it("collapses excessive blank lines", () => {
+    const page = makePage({
+      blocks: [
+        { id: "b1", blockType: "prose", heading: "Block 1", summary: "S1" },
+        { id: "b2", blockType: "prose", heading: "Block 2", summary: "S2" },
+      ],
+    });
+    const result = buildPageMarkdown(page);
+    expect(result).not.toMatch(/\n{3,}/);
+  });
+});

package/src/semantic/tests/page-utils.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import {
+  blocksToMarkdown,
+  extractAnswerBlocksFromMarkdown,
+  toPageEntryId,
+  toSemanticAnswerBlocks,
+} from "../page-utils.ts";
+
+describe("extractAnswerBlocksFromMarkdown", () => {
+  it("extracts h2 sections with content", () => {
+    const md = "## Section 1\n\nContent 1\n\n## Section 2\n\nContent 2";
+    const blocks = extractAnswerBlocksFromMarkdown(md);
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0]).toEqual({ heading: "Section 1", content: "Content 1" });
+    expect(blocks[1]).toEqual({ heading: "Section 2", content: "Content 2" });
+  });
+
+  it("ignores content before first h2", () => {
+    const md = "Intro text\n\n## Section\n\nContent";
+    const blocks = extractAnswerBlocksFromMarkdown(md);
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].heading).toBe("Section");
+  });
+
+  it("returns empty for no h2", () => {
+    expect(extractAnswerBlocksFromMarkdown("Just text")).toEqual([]);
+  });
+});
+
+describe("blocksToMarkdown", () => {
+  it("converts blocks back to markdown", () => {
+    const blocks = [
+      { heading: "Section 1", content: "Content 1" },
+      { heading: "Section 2", content: "Content 2" },
+    ];
+    expect(blocksToMarkdown(blocks)).toBe("## Section 1\n\nContent 1\n\n## Section 2\n\nContent 2");
+  });
+});
+
+describe("toPageEntryId", () => {
+  it("strips language prefix and .html", () => {
+    expect(toPageEntryId(new URL("https://example.com/de/about.html"))).toBe("about");
+  });
+
+  it("handles nested paths", () => {
+    expect(toPageEntryId(new URL("https://example.com/de/section/page"))).toBe("section-page");
+  });
+
+  it("returns index for root", () => {
+    expect(toPageEntryId(new URL("https://example.com/de/"))).toBe("index");
+  });
+});
+
+describe("toSemanticAnswerBlocks", () => {
+  it("produces SemanticBlock with blockType prose", () => {
+    const blocks = [{ heading: "Section", content: "Summary line\n- fact 1\n- fact 2" }];
+    const result = toSemanticAnswerBlocks(blocks);
+    expect(result).toHaveLength(1);
+    expect(result[0].blockType).toBe("prose");
+    expect(result[0].heading).toBe("Section");
+    expect(result[0].summary).toBe("Summary line");
+    expect(result[0].facts).toEqual(["- fact 1", "- fact 2"]);
+  });
+
+  it("preserves table content as summary", () => {
+    const blocks = [
+      {
+        heading: "Pricing",
+        content: "| Col1 | Col2 |\n| --- | --- |\n| a | b |",
+      },
+    ];
+    const result = toSemanticAnswerBlocks(blocks);
+    expect(result[0].summary).toContain("| Col1 | Col2 |");
+    expect(result[0].facts).toBeUndefined();
+  });
+
+  it("preserves multi-paragraph content as summary", () => {
+    const blocks = [
+      {
+        heading: "Section",
+        content: "First paragraph.\n\nSecond paragraph.",
+      },
+    ];
+    const result = toSemanticAnswerBlocks(blocks);
+    expect(result[0].summary).toBe("First paragraph.\n\nSecond paragraph.");
+    expect(result[0].facts).toBeUndefined();
+  });
+});

package/src/{share/tests/price-marker-resolver.test.ts → semantic/tests/price-marker-resolver-0767.test.ts}

@@ -12,8 +12,8 @@ import {
   OFFERING_URI_PREFIX,
   PRICE_MARKER_RE,
   type DerivedPriceEntry,
-} from "../semantic/price-marker-resolver.ts";
-import { loadDerivedPrices } from "../semantic/derived-prices-loader.ts";
+} from "../price-marker-resolver.ts";
+import { loadDerivedPrices } from "../../node/semantic/derived-prices-loader.ts";
 
 const fixturePrices: Record<string, DerivedPriceEntry[]> = {
   [`${OFFERING_URI_PREFIX}referral-fee`]: [

package/src/semantic/tests/price-marker-resolver.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import {
+  OFFERING_URI_PREFIX,
+  PRICE_MARKER_RE,
+  formatSourcePrice,
+  resolveAmountMarkersForSemantic,
+  resolvePriceMarkersForSemantic,
+  type DerivedPriceEntry,
+} from "../price-marker-resolver.ts";
+
+describe("constants", () => {
+  it("OFFERING_URI_PREFIX is warpgogol offerings URL", () => {
+    expect(OFFERING_URI_PREFIX).toBe("https://warpgogol.com/id/offerings/");
+  });
+
+  it("PRICE_MARKER_RE matches price markers", () => {
+    const text = "{price:hosting:monthly}";
+    PRICE_MARKER_RE.lastIndex = 0;
+    const match = PRICE_MARKER_RE.exec(text);
+    expect(match).not.toBeNull();
+    expect(match![1]).toBe("hosting");
+    expect(match![2]).toBe("monthly");
+  });
+});
+
+describe("formatSourcePrice", () => {
+  it("formats EUR amount with narrowSymbol for de", () => {
+    const result = formatSourcePrice("10", "de");
+    expect(result).toContain("10");
+    expect(result).toContain("€");
+  });
+
+  it("returns 0 € for non-numeric amount", () => {
+    expect(formatSourcePrice("not-a-number", "de")).toBe("0\u00A0€");
+  });
+});
+
+describe("resolvePriceMarkersForSemantic", () => {
+  const derivedPrices: Record<string, DerivedPriceEntry[]> = {
+    [`${OFFERING_URI_PREFIX}hosting`]: [
+      {
+        chargeRef: "monthly",
+        targetCurrency: "USD",
+        amount: { value: "15", currency: "USD" },
+        trace: {
+          source: { amount: "10", currency: "EUR" },
+          rate: { value: "0.9", pair: "EUR/USD" },
+        },
+      },
+    ],
+  };
+
+  it("resolves price marker to source currency", () => {
+    const result = resolvePriceMarkersForSemantic(
+      "Price: {price:hosting:monthly}",
+      "de",
+      derivedPrices,
+    );
+    expect(result).toContain("10");
+    expect(result).toContain("€");
+    expect(result).not.toContain("{price:");
+  });
+
+  it("returns 0 € for unknown offering", () => {
+    const result = resolvePriceMarkersForSemantic(
+      "Price: {price:unknown:charge}",
+      "de",
+      derivedPrices,
+    );
+    expect(result).toContain("0");
+    expect(result).toContain("€");
+  });
+
+  it("returns text unchanged when no markers", () => {
+    expect(resolvePriceMarkersForSemantic("No markers", "de", derivedPrices)).toBe("No markers");
+  });
+});
+
+describe("resolveAmountMarkersForSemantic", () => {
+  it("resolves amount marker to EUR", () => {
+    const result = resolveAmountMarkersForSemantic("Threshold: {amount:50}", "de");
+    expect(result).toContain("50");
+    expect(result).toContain("€");
+    expect(result).not.toContain("{amount:");
+  });
+
+  it("returns text unchanged when no markers", () => {
+    expect(resolveAmountMarkersForSemantic("No markers", "de")).toBe("No markers");
+  });
+});

package/src/semantic/tests/project-claims.pbt.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it } from "vitest";
+import fc from "fast-check";
+import { projectClaims } from "../business-projection.ts";
+
+describe("projectClaims — property-based (AC-4)", () => {
+  it("is deterministic — same input always produces same output", () => {
+    fc.assert(
+      fc.property(
+        fc.array(
+          fc.record({
+            id: fc.string({ minLength: 1 }),
+            status: fc.constant("published"),
+            statement: fc.string(),
+            claimClass: fc.string(),
+            claimKind: fc.string(),
+          }),
+        ),
+        (claims) => {
+          const a = projectClaims(claims, undefined);
+          const b = projectClaims(claims, undefined);
+          expect(a).toEqual(b);
+        },
+      ),
+      { numRuns: 50 },
+    );
+  });
+
+  it("only returns claims with status === published", () => {
+    fc.assert(
+      fc.property(
+        fc.array(
+          fc.record({
+            id: fc.string({ minLength: 1 }),
+            status: fc.oneof(fc.constant("published"), fc.constant("draft"), fc.constant("archived")),
+            statement: fc.string(),
+            claimClass: fc.string(),
+            claimKind: fc.string(),
+          }),
+        ),
+        (claims) => {
+          const result = projectClaims(claims, undefined);
+          for (const c of result) {
+            expect(c.id).toBeTruthy();
+          }
+          const publishedIds = claims.filter((c) => c.status === "published" && c.id).map((c) => c.id);
+          expect(result.map((c) => c.id).sort()).toEqual(publishedIds.sort());
+        },
+      ),
+      { numRuns: 50 },
+    );
+  });
+
+  it("returns empty array for empty or undefined input", () => {
+    fc.assert(
+      fc.property(fc.oneof(fc.constant(undefined), fc.constant([])), (input) => {
+        expect(projectClaims(input, undefined)).toEqual([]);
+      }),
+    );
+  });
+});

package/src/semantic/tests/robots.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { buildRobotsTxt } from "../robots.ts";
+
+describe("buildRobotsTxt", () => {
+  it("generates default allow policy", () => {
+    const result = buildRobotsTxt({});
+    expect(result).toContain("User-agent: *");
+    expect(result).not.toContain("Disallow: /");
+    expect(result).toContain("Allow: /robots.txt");
+    expect(result).toContain("Sitemap: /sitemap.xml");
+  });
+
+  it("generates disallow-all for defaultPolicy: disallow", () => {
+    const result = buildRobotsTxt({ defaultPolicy: "disallow" });
+    expect(result).toContain("Disallow: /");
+  });
+
+  it("generates specific disallow paths", () => {
+    const result = buildRobotsTxt({ disallowedPaths: ["/admin", "/private"] });
+    expect(result).toContain("Disallow: /admin");
+    expect(result).toContain("Disallow: /private");
+    expect(result).not.toContain("Disallow: /\n");
+  });
+
+  it("generates allow paths in allow mode", () => {
+    const result = buildRobotsTxt({ allowedPaths: ["/public"] });
+    expect(result).toContain("Allow: /public");
+  });
+
+  it("emits Content-Signal directive when provided", () => {
+    const result = buildRobotsTxt({ contentSignal: ["ai-train", "search"] });
+    expect(result).toContain("Content-Signal: ai-train, search");
+  });
+
+  it("emits crawler blocklist", () => {
+    const result = buildRobotsTxt({ crawlerBlocklist: ["BadBot", "ScraperBot"] });
+    expect(result).toContain("User-agent: BadBot");
+    expect(result).toContain("User-agent: ScraperBot");
+    expect(result).toContain("Disallow: /");
+  });
+
+  it("emits crawler allowlist", () => {
+    const result = buildRobotsTxt({ crawlerAllowlist: ["FriendlyBot"] });
+    expect(result).toContain("User-agent: FriendlyBot");
+    expect(result).toContain("Allow: /");
+  });
+
+  it("emits custom per-user-agent rules", () => {
+    const result = buildRobotsTxt({
+      customRules: [{ userAgent: "GoogleBot", disallow: ["/no-google"], allow: ["/yes-google"] }],
+    });
+    expect(result).toContain("User-agent: GoogleBot");
+    expect(result).toContain("Disallow: /no-google");
+    expect(result).toContain("Allow: /yes-google");
+  });
+
+  it("uses custom sitemap URL", () => {
+    const result = buildRobotsTxt({ sitemap: "https://example.com/sitemap.xml" });
+    expect(result).toContain("Sitemap: https://example.com/sitemap.xml");
+  });
+
+  it("always allows auxiliary discovery files", () => {
+    const result = buildRobotsTxt({ defaultPolicy: "disallow" });
+    expect(result).toContain("Allow: /robots.txt");
+    expect(result).toContain("Allow: /llms.txt");
+    expect(result).toContain("Allow: /llms-full.txt");
+    expect(result).toContain("Allow: /sitemap.xml");
+    expect(result).toContain("Allow: /sitemap-content.xml");
+  });
+});

package/src/{share/semantic → semantic}/tests/split-sentences.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { splitSentences } from "@warpgogol/werkstatt-shared/share/semantic";
+import { splitSentences } from "@warpgogol/werkstatt-shared/semantic";
 
 describe("splitSentences", () => {
   it("splits simple English sentences", () => {

package/src/{share → semantic}/tests/twin-path.test.ts

@@ -18,7 +18,7 @@
 */
 
 import { test, expect } from "vitest";
-import { markdownTwinRelPath, markdownTwinUrlPath } from "../semantic/ids.ts";
+import { markdownTwinRelPath, markdownTwinUrlPath } from "../ids.ts";
 
 const supportedLangs = ["de", "en"] as const;