@warpgogol/werkstatt-shared 0.14.0 → 0.14.1

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

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import {
+  AMOUNT_MARKER_RE,
+  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/share/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/tests/update-stamp.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "vitest";
+import {
+  isValidStampDate,
+  resolveAuthoredStamp,
+  resolveCklStamp,
+  resolvePageUpdateStamp,
+} from "../update-stamp.ts";
+
+describe("isValidStampDate", () => {
+  it("accepts YYYY-MM-DD", () => {
+    expect(isValidStampDate("2024-01-15")).toBe(true);
+  });
+
+  it("rejects non-string", () => {
+    expect(isValidStampDate(20240115)).toBe(false);
+  });
+
+  it("rejects wrong format", () => {
+    expect(isValidStampDate("2024/01/15")).toBe(false);
+    expect(isValidStampDate("January 15, 2024")).toBe(false);
+  });
+});
+
+describe("resolveAuthoredStamp", () => {
+  it("uses output.sitemap.lastmod first", () => {
+    const result = resolveAuthoredStamp({
+      output: { sitemap: { lastmod: "2024-06-01" } },
+    });
+    expect(result?.date).toBe("2024-06-01");
+    expect(result?.source).toBe("authored-system-output");
+  });
+
+  it("uses article.updatedAt when no sitemap lastmod", () => {
+    const result = resolveAuthoredStamp({
+      article: { updatedAt: "2024-05-01" },
+    });
+    expect(result?.date).toBe("2024-05-01");
+    expect(result?.source).toBe("authored-page-frontmatter");
+  });
+
+  it("uses article.publishedAt when no updatedAt", () => {
+    const result = resolveAuthoredStamp({
+      article: { publishedAt: "2024-01-01" },
+    });
+    expect(result?.date).toBe("2024-01-01");
+  });
+
+  it("returns undefined when no valid dates", () => {
+    expect(resolveAuthoredStamp({})).toBeUndefined();
+  });
+
+  it("ignores invalid date formats", () => {
+    expect(resolveAuthoredStamp({ article: { updatedAt: "not-a-date" } })).toBeUndefined();
+  });
+});
+
+describe("resolveCklStamp", () => {
+  it("returns latest valid date", () => {
+    const result = resolveCklStamp(["2024-01-01", "2024-06-15", "2024-03-01"], ["ledger"]);
+    expect(result?.date).toBe("2024-06-15");
+    expect(result?.source).toBe("ckl-claim-ledger");
+  });
+
+  it("returns undefined when no valid dates", () => {
+    expect(resolveCklStamp(["invalid"], ["ledger"])).toBeUndefined();
+  });
+});
+
+describe("resolvePageUpdateStamp", () => {
+  it("prefers authored stamp over CKL", () => {
+    const result = resolvePageUpdateStamp({
+      pageId: "p1",
+      lang: "de",
+      pageEntry: { output: { sitemap: { lastmod: "2024-06-01" } } },
+      cklLedgerDates: ["2024-01-01"],
+    });
+    expect(result.stamp?.date).toBe("2024-06-01");
+    expect(result.stamp?.source).toBe("authored-system-output");
+  });
+
+  it("falls back to CKL when no authored stamp", () => {
+    const result = resolvePageUpdateStamp({
+      pageId: "p1",
+      lang: "de",
+      pageEntry: {},
+      cklLedgerDates: ["2024-03-01"],
+      cklInputs: ["ledger"],
+    });
+    expect(result.stamp?.date).toBe("2024-03-01");
+    expect(result.stamp?.source).toBe("ckl-claim-ledger");
+  });
+
+  it("returns missingReason when no sources available", () => {
+    const result = resolvePageUpdateStamp({
+      pageId: "p1",
+      lang: "de",
+      pageEntry: {},
+    });
+    expect(result.stamp).toBeUndefined();
+    expect(result.missingReason).toBe("no-content-source");
+  });
+});

package/src/share/utility-registry.yaml

@@ -34,3 +34,17 @@ utilities:
     allowlist:
       - path: packages/werkstatt-shared/src/share/routes/
         reason: Canonical placeholder route filter — owns all template detection logic (RFC-0917)
+  - id: remediation-catalog
+    canonicalPath: packages/werkstatt-shared/src/share/remediation/
+    forbiddenImports: []
+    functionNames:
+      - lookupRemediation
+      - REMEDIATION_CATALOG
+    patterns: []
+    allowlist:
+      - path: packages/werkstatt-shared/src/share/remediation/
+        reason: Canonical remediation catalog — owns all ruleId-to-remediation-pattern mappings (RFC-1027)
+      - path: packages/werkstatt-shared/src/checks/result-helpers.ts
+        reason: Consumes lookupRemediation to auto-populate Diagnostic.remediation (RFC-1027)
+      - path: packages/werkstatt-engine/src/remediation/
+        reason: Engine remediation module reads REMEDIATION_CATALOG for catalog.generate and hint.validate (RFC-1027)