@anthusai/papyrus 0.0.0 → 1.0.0-next.1

package/lib/reference-display.ts

@@ -0,0 +1,74 @@
+import type { HydratedModelPayload } from "./category-repository";
+import type { ReferenceRecord } from "./category-repository";
+import type { SemanticGraphSnapshot } from "./semantic-graph";
+
+function metadataRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value === "string") {
+    try {
+      return metadataRecord(JSON.parse(value));
+    } catch {
+      return null;
+    }
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value as Record<string, unknown>;
+}
+
+function normalizeDisplayText(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+
+export function referenceMetadataField(
+  payload: HydratedModelPayload | null,
+  fallback: unknown,
+  key: "title" | "subtitle" | "summary",
+): string | null {
+  const payloadRecord = metadataRecord(payload?.json);
+  if (payloadRecord) {
+    const value = normalizeDisplayText(payloadRecord[key]);
+    if (value) return value;
+  }
+  const fallbackRecord = metadataRecord(fallback);
+  return fallbackRecord ? normalizeDisplayText(fallbackRecord[key]) : null;
+}
+
+export function referenceSummaryFromGraph(graph: SemanticGraphSnapshot | null | undefined, lineageId: string): string | null {
+  if (!graph || !lineageId) return null;
+  for (const message of graph.summariesFor("reference", lineageId)) {
+    const summary = normalizeDisplayText(message.summary);
+    if (!summary) continue;
+    if (/can['’]t summarize|don['’]t have the document|link alone/i.test(summary)) continue;
+    return summary;
+  }
+  return null;
+}
+
+export function referenceDisplaySummary(
+  graph: SemanticGraphSnapshot | null | undefined,
+  lineageId: string,
+  payload: HydratedModelPayload | null,
+  fallback?: unknown,
+): string | null {
+  return referenceMetadataField(payload, fallback, "summary")
+    ?? referenceSummaryFromGraph(graph, lineageId);
+}
+
+export function resolveCanonicalReferenceLineage(
+  references: ReferenceRecord[],
+  requestedLineageId: string,
+): string {
+  if (!requestedLineageId) return requestedLineageId;
+  const target = references.find((reference) => (reference.lineageId ?? reference.id) === requestedLineageId);
+  if (!target?.sourceUri) return requestedLineageId;
+  const duplicates = references.filter((reference) =>
+    reference.versionState === "current"
+    && reference.sourceUri === target.sourceUri);
+  if (duplicates.length <= 1) return requestedLineageId;
+  const preferred = duplicates.find((reference) => reference.curationStatus !== "archived")
+    ?? duplicates.find((reference) => !(reference.lineageId ?? "").includes("research-proposal"))
+    ?? target;
+  return preferred.lineageId ?? preferred.id ?? requestedLineageId;
+}
+

package/lib/reference-policy.ts

@@ -0,0 +1,97 @@
+import type { MessageRecord, ReferenceRecord } from "./category-repository";
+
+export const REFERENCE_CURATION_STATUSES = ["pending", "accepted", "rejected", "archived"] as const;
+export type ReferenceCurationStatus = typeof REFERENCE_CURATION_STATUSES[number];
+
+export const REFERENCE_REJECTION_REASON_CODES = [
+  "out_of_scope",
+  "policy_exclusion",
+  "duplicate",
+  "low_quality",
+  "unavailable",
+  "provenance",
+  "other",
+] as const;
+export type ReferenceRejectionReasonCode = typeof REFERENCE_REJECTION_REASON_CODES[number];
+
+const REFERENCE_REJECTION_REASON_CODE_SET = new Set<string>(REFERENCE_REJECTION_REASON_CODES);
+const SCOPE_TRAINING_NEGATIVE_REASON_CODE_SET = new Set<string>(["out_of_scope", "policy_exclusion"]);
+
+export function normalizeReferenceCurationStatus(value: unknown, defaultStatus: ReferenceCurationStatus = "pending"): ReferenceCurationStatus {
+  const normalized = normalizePolicyToken(value ?? defaultStatus);
+  if (normalized === "accepted" || normalized === "accept" || normalized === "ready" || normalized === "trusted") return "accepted";
+  if (normalized === "rejected" || normalized === "reject" || normalized === "discarded") return "rejected";
+  if (normalized === "archived" || normalized === "archive") return "archived";
+  return "pending";
+}
+
+export function referenceCurationStatusForAction(action: "accept" | "reject" | "reopen" | "archive"): ReferenceCurationStatus {
+  if (action === "accept") return "accepted";
+  if (action === "reject") return "rejected";
+  if (action === "archive") return "archived";
+  return "pending";
+}
+
+export function normalizeReferenceRejectionReasonCode(value: unknown): ReferenceRejectionReasonCode | null {
+  const normalized = normalizePolicyToken(value);
+  if (!normalized) return null;
+  return REFERENCE_REJECTION_REASON_CODE_SET.has(normalized) ? normalized as ReferenceRejectionReasonCode : null;
+}
+
+export function isEvidenceEligibleReference(reference: Pick<ReferenceRecord, "versionState" | "curationStatus"> | null | undefined): boolean {
+  return Boolean(reference)
+    && reference?.versionState === "current"
+    && normalizeReferenceCurationStatus(reference?.curationStatus) === "accepted";
+}
+
+export function referenceReasonCode(reference: Pick<ReferenceRecord, "metadata"> | null | undefined, messages: Array<Pick<MessageRecord, "metadata" | "createdAt">> = []): ReferenceRejectionReasonCode | null {
+  const metadataReason = reasonCodeFromMetadata(reference?.metadata);
+  if (metadataReason) return metadataReason;
+  const sortedMessages = [...messages].sort((left, right) => String(right.createdAt ?? "").localeCompare(String(left.createdAt ?? "")));
+  for (const message of sortedMessages) {
+    const reason = reasonCodeFromMetadata(message.metadata);
+    if (reason) return reason;
+  }
+  return null;
+}
+
+export function scopeTrainingLabelForReference(reference: Pick<ReferenceRecord, "versionState" | "curationStatus" | "metadata"> | null | undefined, messages: Array<Pick<MessageRecord, "metadata" | "createdAt">> = []): "positive" | "negative" | null {
+  if (!reference || reference.versionState !== "current") return null;
+  const status = normalizeReferenceCurationStatus(reference.curationStatus);
+  if (status === "accepted") return "positive";
+  if (status !== "rejected") return null;
+  const reasonCode = referenceReasonCode(reference, messages);
+  return reasonCode && SCOPE_TRAINING_NEGATIVE_REASON_CODE_SET.has(reasonCode) ? "negative" : null;
+}
+
+function reasonCodeFromMetadata(metadata: unknown): ReferenceRejectionReasonCode | null {
+  const parsed = parseMetadataObject(metadata);
+  return normalizeReferenceRejectionReasonCode(
+    parsed.reasonCode
+      ?? parsed.reason_code
+      ?? parsed.curationReasonCode
+      ?? parsed.curation_reason_code
+      ?? parsed.rejectionReasonCode
+      ?? parsed.rejection_reason_code,
+  );
+}
+
+function parseMetadataObject(value: unknown): Record<string, unknown> {
+  if (!value) return {};
+  if (typeof value === "object" && !Array.isArray(value)) return value as Record<string, unknown>;
+  if (typeof value !== "string") return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizePolicyToken(value: unknown): string {
+  return String(value ?? "")
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_|_$/g, "");
+}

package/lib/reference-source-preview.ts

@@ -0,0 +1,175 @@
+import type { ReferenceAttachmentRecord } from "./category-repository";
+
+export type ReferenceSourcePreview =
+  | {
+      kind: "youtube";
+      videoId: string;
+      embedUrl: string;
+      thumbnailUrl: string;
+      watchUrl: string;
+    }
+  | {
+      kind: "pdf";
+      href: string;
+      label: string;
+      embedUrl: string;
+    }
+  | {
+      kind: "html";
+      href: string;
+      label: string;
+    };
+
+export function youtubeVideoIdFromUri(sourceUri: string): string | null {
+  try {
+    const parsed = new URL(sourceUri);
+    const host = parsed.hostname.toLowerCase();
+    if (host === "youtu.be") {
+      const token = parsed.pathname.replace(/^\/+/, "").split("/")[0] ?? "";
+      return token || null;
+    }
+    if (host === "youtube.com" || host === "www.youtube.com" || host === "m.youtube.com") {
+      const fromQuery = parsed.searchParams.get("v");
+      if (fromQuery) return fromQuery;
+      if (parsed.pathname.startsWith("/shorts/")) {
+        return parsed.pathname.slice("/shorts/".length).split("/")[0] || null;
+      }
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+export function isPdfAttachment(attachment: ReferenceAttachmentRecord): boolean {
+  const mediaType = (attachment.mediaType ?? "").toLowerCase();
+  if (mediaType.includes("pdf")) return true;
+  const path = `${attachment.storagePath ?? ""} ${attachment.sourceUri ?? ""} ${attachment.filename ?? ""}`.toLowerCase();
+  return path.includes(".pdf");
+}
+
+function isHtmlAttachment(attachment: ReferenceAttachmentRecord): boolean {
+  const mediaType = (attachment.mediaType ?? "").toLowerCase();
+  if (mediaType.includes("html")) return true;
+  const path = `${attachment.storagePath ?? ""} ${attachment.sourceUri ?? ""} ${attachment.filename ?? ""}`.toLowerCase();
+  return path.endsWith(".html") || path.endsWith(".htm");
+}
+
+export function isCitationLandingPageUrl(uri: string): boolean {
+  try {
+    const parsed = new URL(uri);
+    const host = parsed.hostname.toLowerCase();
+    const path = parsed.pathname.toLowerCase();
+    if (host.endsWith("arxiv.org") && path.startsWith("/abs/")) return true;
+    if (host === "doi.org" || host.endsWith(".doi.org")) return true;
+    if (host.includes("pubmed") && path.includes("/")) return true;
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+export function isDirectPdfUrl(uri: string): boolean {
+  try {
+    const parsed = new URL(uri);
+    if (parsed.pathname.toLowerCase().endsWith(".pdf")) return true;
+    if (parsed.searchParams.get("response-content-type")?.toLowerCase().includes("pdf")) return true;
+  } catch {
+    return uri.toLowerCase().includes(".pdf");
+  }
+  return uri.toLowerCase().includes(".pdf");
+}
+
+export function pickPdfAttachmentHref(
+  attachment: ReferenceAttachmentRecord,
+  referenceSourceUri?: string | null,
+): string | null {
+  const candidates = [attachment.sourceUri, referenceSourceUri].filter(
+    (value): value is string => Boolean(value?.trim()),
+  );
+
+  for (const candidate of candidates) {
+    if (isDirectPdfUrl(candidate)) return candidate;
+  }
+
+  for (const candidate of candidates) {
+    if (!isCitationLandingPageUrl(candidate)) return candidate;
+  }
+
+  return null;
+}
+
+function pdfPreviewFromUri(sourceUri: string | null | undefined): ReferenceSourcePreview | null {
+  if (!sourceUri) return null;
+  if (!isDirectPdfUrl(sourceUri)) return null;
+  return {
+    kind: "pdf",
+    href: sourceUri,
+    embedUrl: sourceUri,
+    label: "Open PDF source",
+  };
+}
+
+function htmlPreviewFromUri(sourceUri: string | null | undefined): ReferenceSourcePreview | null {
+  if (!sourceUri) return null;
+  try {
+    const parsed = new URL(sourceUri);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+    if (youtubeVideoIdFromUri(sourceUri)) return null;
+    const lowerPath = parsed.pathname.toLowerCase();
+    if (lowerPath.endsWith(".pdf")) return null;
+    return { kind: "html", href: sourceUri, label: "Open web source" };
+  } catch {
+    return null;
+  }
+}
+
+export function resolveReferenceSourcePreview(
+  sourceUri: string | null | undefined,
+  attachments: ReferenceAttachmentRecord[] = [],
+): ReferenceSourcePreview | null {
+  const videoId = sourceUri ? youtubeVideoIdFromUri(sourceUri) : null;
+  if (videoId) {
+    const watchUrl = `https://www.youtube.com/watch?v=${encodeURIComponent(videoId)}`;
+    return {
+      kind: "youtube",
+      videoId,
+      embedUrl: `https://www.youtube-nocookie.com/embed/${encodeURIComponent(videoId)}`,
+      thumbnailUrl: `https://i.ytimg.com/vi/${encodeURIComponent(videoId)}/hqdefault.jpg`,
+      watchUrl,
+    };
+  }
+
+  const pdfAttachment = attachments.find((attachment) => isPdfAttachment(attachment));
+  if (pdfAttachment) {
+    const href = pickPdfAttachmentHref(pdfAttachment, sourceUri);
+    if (href) {
+      return {
+        kind: "pdf",
+        href,
+        embedUrl: href,
+        label: pdfAttachment.filename ?? "Open PDF attachment",
+      };
+    }
+  }
+
+  const pdfFromUri = pdfPreviewFromUri(sourceUri);
+  if (pdfFromUri) return pdfFromUri;
+
+  const htmlAttachment = attachments.find((attachment) => isHtmlAttachment(attachment));
+  if (htmlAttachment) {
+    const candidates = [htmlAttachment.sourceUri, htmlAttachment.storagePath, sourceUri].filter(
+      (value): value is string => Boolean(value?.trim()),
+    );
+    const href = candidates.find((candidate) => !isCitationLandingPageUrl(candidate)) ?? candidates[0];
+    if (href) {
+      return {
+        kind: "html",
+        href,
+        label: htmlAttachment.filename ?? "Open HTML attachment",
+      };
+    }
+  }
+
+  return htmlPreviewFromUri(sourceUri);
+}

package/lib/renderer-config.ts

@@ -0,0 +1,50 @@
+import type { EditionLayoutPlan } from "./layout-plan";
+
+export type PretextLayout = "newsprint" | "blog" | "magazine";
+
+export type PretextRendererConfig = {
+  kind: "pretext";
+  layout: PretextLayout;
+  layoutPlan: EditionLayoutPlan;
+};
+
+export type MarkusRendererConfig = {
+  kind: "markus";
+  theme: string;
+};
+
+export type RendererConfig = PretextRendererConfig | MarkusRendererConfig;
+
+/** Sibling deploy target — type-only in PPY-eca592; not a required SiteBrand field. */
+export type HostingConfig =
+  | { kind: "amplify-ssr" }
+  | { kind: "amplify-static" };
+
+export function isPretextRendererConfig(config: RendererConfig): config is PretextRendererConfig {
+  return config.kind === "pretext";
+}
+
+export function isMarkusRendererConfig(config: RendererConfig): config is MarkusRendererConfig {
+  return config.kind === "markus";
+}
+
+export function assertPretextRendererConfig(config: RendererConfig): PretextRendererConfig {
+  if (config.kind !== "pretext") {
+    throw new Error(
+      `Site renderer is "${config.kind}"; Next.js reader routes require kind "pretext". `
+      + "Markus sites use `poetry run papyrus renderers markus-build` and static hosting.",
+    );
+  }
+  return config;
+}
+
+export class MarkusSiteRendererError extends Error {
+  constructor(theme: string, siteBrandId = "unknown") {
+    super(
+      `Site brand "${siteBrandId}" uses Markus renderer (theme "${theme}"). `
+      + "Next.js reader routes are not available. "
+      + "Build with `poetry run papyrus renderers markus-build` and serve `web/dist/` statically.",
+    );
+    this.name = "MarkusSiteRendererError";
+  }
+}

package/lib/renderer.ts

@@ -0,0 +1,87 @@
+import type { ComponentType } from "react";
+import type { Article } from "./articles";
+import type { EditionContent } from "./content-types";
+import type { PretextLayout } from "./renderer-config";
+import type { PresentationFooterEntry } from "./presentation-footer";
+import type { PublicationItem } from "./publication-items";
+
+/**
+ * Renderer is the swappable render pipeline that turns standard content
+ * (`EditionContent` / `PublicationItem` / `Article`) into a site: today
+ * `"pretext"` (the existing client-side layout solver), with `"markus"`
+ * (Anthus-flavored Markdown -> static HTML) as the second implementation
+ * this shape is designed to admit. See docs/pluggable-publishers.md.
+ *
+ * `Layout` (`"newsprint" | "blog" | "magazine"`, `PretextLayout`
+ * below) is a *Pretext-internal* concern -- it is the look within Pretext,
+ * not a concept every renderer needs to understand. A renderer that isn't
+ * Pretext may support none of these layouts; `supportsLayout` is how a
+ * caller finds out.
+ */
+export type RendererId = "pretext" | "markus";
+
+export type PresentationTarget =
+  | { kind: "edition" }
+  | { kind: "section"; sectionKey: string };
+
+export type RenderEditionProps = {
+  content: EditionContent;
+  editionBasePath?: string;
+  mastheadHomeHref?: string;
+  initialPageNumber?: number;
+  lockedPresentation?: PretextLayout;
+  target?: PresentationTarget;
+};
+
+export type ArticlePageEditionFooter = {
+  editionBasePath: string;
+  entries: PresentationFooterEntry[];
+  subtitle: string;
+  title?: string;
+};
+
+export type RenderArticleProps = {
+  article: Article;
+  backHref: string;
+  backLabel?: string;
+  editionFooter?: ArticlePageEditionFooter;
+  editionDate?: string;
+};
+
+export type RenderItemProps = {
+  item: PublicationItem;
+  backHref: string;
+  backLabel?: string;
+  editionFooter?: ArticlePageEditionFooter;
+  editionDate?: string;
+};
+
+/**
+ * The operations below are derived directly from real call sites, not
+ * guessed:
+ *
+ * - `renderEdition` backs `PresentationShell`, used by the date-scoped
+ *   edition route (`app/[year]/[month]/[day]/edition-route-page.tsx`).
+ * - `renderArticle` / `renderItem` back `ArticlePageView` / `ItemPageView`,
+ *   used directly by `app/articles/[slug]/page.tsx` and
+ *   `app/[year]/[month]/[day]/[articleSlug]/page.tsx`.
+ * - `stylesheets` lets a renderer declare CSS it owns. Pretext's CSS is not
+ *   currently extracted from the monolithic `app/globals.css` bundle (it is
+ *   imported unconditionally by `app/layout.tsx` regardless of renderer), so
+ *   its implementation returns an empty array today -- this hook exists so a
+ *   future static-output renderer (Markus's vendored + per-site CSS layers,
+ *   see docs/pluggable-publishers.md section 6) has somewhere real to report
+ *   the stylesheets it needs mounted.
+ * - `supportsLayout` is the capability/validation hook: since Layout is
+ *   Pretext-internal, a renderer must be able to say which layouts (if any)
+ *   it understands, rather than every caller assuming all renderers share
+ *   Pretext's three layouts.
+ */
+export type Renderer = {
+  id: RendererId;
+  renderEdition: ComponentType<RenderEditionProps>;
+  renderArticle: ComponentType<RenderArticleProps>;
+  renderItem: ComponentType<RenderItemProps>;
+  stylesheets(): string[];
+  supportsLayout(layout: PretextLayout): boolean;
+};