@anthusai/papyrus 0.0.0 → 1.0.0-next.1

package/lib/newsroom-assignments.ts

@@ -0,0 +1,173 @@
+import type { AssignmentRecord, NewsroomSummaryRecord } from "./category-repository";
+
+export type AssignmentStatusFilter = "all" | "open" | "claimed" | "completed" | "canceled";
+
+export type AssignmentAction = "claim" | "release" | "complete" | "cancel" | "reopen" | "retry";
+
+export type AssignmentTypeOption = {
+  key: string;
+  label: string;
+  count: number;
+};
+
+export type AssignmentMetrics = {
+  total: number;
+  open: number;
+  claimed: number;
+  completed: number;
+  canceled: number;
+};
+
+export function assignmentTypeKeyForFilter(assignment: AssignmentRecord): string {
+  return assignment.assignmentTypeKey?.trim() || "unknown";
+}
+
+export function formatAssignmentTypeLabel(typeKey: string | null | undefined): string {
+  const key = typeKey?.trim();
+  if (!key) return "Uncategorized";
+  if (key === "analysis.reindex") return "Analysis re-index";
+  if (key === "newsroom.research" || key === "research") return "Research";
+  if (key === "curation.reference-intake") return "Reference intake";
+  if (key === "reporting.edition-candidate") return "Reporting candidate";
+  return key
+    .split(/[.:_-]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(" ");
+}
+
+export function getAssignmentTypeOptions(
+  assignments: AssignmentRecord[],
+  summary?: NewsroomSummaryRecord | null,
+): AssignmentTypeOption[] {
+  const summaryCounts = summary?.facets?.assignments?.byType ?? summary?.assignmentTypeCounts;
+  const countByType = summaryCounts && Object.keys(summaryCounts).length
+    ? new Map(Object.entries(summaryCounts))
+    : new Map<string, number>();
+  if (!countByType.size) {
+    for (const assignment of assignments) {
+      const typeKey = assignmentTypeKeyForFilter(assignment);
+      countByType.set(typeKey, (countByType.get(typeKey) ?? 0) + 1);
+    }
+  }
+  return Array.from(countByType.entries())
+    .map(([key, count]) => ({
+      key,
+      label: formatAssignmentTypeLabel(key),
+      count,
+    }))
+    .sort((left, right) => {
+      const countDiff = right.count - left.count;
+      if (countDiff !== 0) return countDiff;
+      return left.label.localeCompare(right.label);
+    });
+}
+
+export function getAssignmentMetrics(
+  assignments: AssignmentRecord[],
+  summary?: NewsroomSummaryRecord | null,
+  typeFilter?: string,
+): AssignmentMetrics {
+  const statusCounts = typeFilter
+    ? summary?.facets?.assignments?.statusByType?.[typeFilter]
+    : summary?.facets?.assignments?.byStatus ?? summary?.assignmentStatusCounts;
+  if (statusCounts && Object.keys(statusCounts).length) {
+    return {
+      total: Object.values(statusCounts).reduce((sum, count) => sum + count, 0),
+      open: statusCounts.open ?? 0,
+      claimed: statusCounts.claimed ?? 0,
+      completed: statusCounts.completed ?? 0,
+      canceled: statusCounts.canceled ?? 0,
+    };
+  }
+  return {
+    total: assignments.length,
+    open: assignments.filter((assignment) => assignment.status === "open").length,
+    claimed: assignments.filter((assignment) => assignment.status === "claimed").length,
+    completed: assignments.filter((assignment) => assignment.status === "completed").length,
+    canceled: assignments.filter((assignment) => assignment.status === "canceled").length,
+  };
+}
+
+function assignmentStatusRank(status: string): number {
+  if (status === "open") return 0;
+  if (status === "claimed") return 1;
+  if (status === "completed") return 6;
+  if (status === "canceled") return 8;
+  return 5;
+}
+
+export function compareAssignments(left: AssignmentRecord, right: AssignmentRecord): number {
+  const leftStatus = assignmentStatusRank(left.status);
+  const rightStatus = assignmentStatusRank(right.status);
+  if (leftStatus !== rightStatus) return leftStatus - rightStatus;
+  const priorityDiff = (left.priority ?? 999999) - (right.priority ?? 999999);
+  if (priorityDiff !== 0) return priorityDiff;
+  return left.createdAt.localeCompare(right.createdAt);
+}
+
+export function countAssignmentsByStatus(assignments: AssignmentRecord[]): Record<string, number> {
+  const counts: Record<string, number> = {};
+  for (const assignment of assignments) {
+    const status = assignment.status?.trim().toLowerCase() || "unknown";
+    counts[status] = (counts[status] ?? 0) + 1;
+  }
+  return counts;
+}
+
+export function filterAssignmentsByStatus(
+  assignments: AssignmentRecord[],
+  statusFilter: AssignmentStatusFilter,
+): AssignmentRecord[] {
+  const sorted = [...assignments].sort(compareAssignments);
+  if (statusFilter === "all") return sorted;
+  return sorted.filter((assignment) => assignment.status === statusFilter);
+}
+
+export function formatAssignmentListDate(assignment: AssignmentRecord): string {
+  const value = assignment.updatedAt ?? assignment.createdAt ?? "";
+  if (!value) return "Undated";
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) return value;
+  return new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    timeZone: "UTC",
+  }).format(new Date(timestamp));
+}
+
+export function assignmentStatusLabel(status: string): string {
+  const normalized = status?.trim().toLowerCase() ?? "";
+  if (normalized === "open") return "Open";
+  if (normalized === "claimed") return "Claimed";
+  if (normalized === "completed") return "Completed";
+  if (normalized === "canceled") return "Canceled";
+  return status || "Unknown";
+}
+
+export function assignmentStatusBadgeVariant(
+  status: string,
+): "default" | "secondary" | "outline" | "muted" {
+  const normalized = status?.trim().toLowerCase() ?? "";
+  if (normalized === "open") return "default";
+  if (normalized === "claimed") return "secondary";
+  if (normalized === "completed") return "outline";
+  if (normalized === "canceled") return "outline";
+  return "muted";
+}
+
+export function assignmentListSubtitle(assignment: AssignmentRecord): string {
+  const typeLabel = formatAssignmentTypeLabel(assignment.assignmentTypeKey);
+  const section = assignment.sectionKey?.trim() || assignment.sectionId?.trim();
+  if (section) return `${typeLabel} · ${section}`;
+  return typeLabel;
+}
+
+export function selectedAssignmentById(
+  assignments: AssignmentRecord[],
+  assignmentId: string | null | undefined,
+): AssignmentRecord | null {
+  if (!assignmentId) return null;
+  return assignments.find((assignment) => assignment.id === assignmentId) ?? null;
+}

package/lib/newsroom-base-path.ts

@@ -0,0 +1,48 @@
+import { SITE_BRAND } from "./site-brand";
+
+const DEFAULT_NEWSROOM_BASE_PATH = "/newsroom";
+
+/** Internal Next.js route prefix (always `/newsroom/...`). */
+export function getInternalNewsroomBasePath(): string {
+  return DEFAULT_NEWSROOM_BASE_PATH;
+}
+
+/** Public browser path prefix (`""` on a CMS-only newsroom subdomain). */
+export function getPublicNewsroomBasePath(): string {
+  return SITE_BRAND.newsroomBasePath ?? DEFAULT_NEWSROOM_BASE_PATH;
+}
+
+export function usesNewsroomRootPaths(): boolean {
+  return getPublicNewsroomBasePath() === "";
+}
+
+export function toPublicNewsroomPath(internalPath: string): string {
+  const publicBase = getPublicNewsroomBasePath();
+  if (publicBase !== "") return internalPath;
+  if (internalPath === "/newsroom" || internalPath === "/newsroom/") return "/";
+  if (internalPath.startsWith("/newsroom/")) {
+    return internalPath.slice("/newsroom".length) || "/";
+  }
+  return internalPath;
+}
+
+export function toInternalNewsroomPath(publicPath: string): string {
+  const publicBase = getPublicNewsroomBasePath();
+  const normalized = publicPath.startsWith("/") ? publicPath : `/${publicPath}`;
+  if (publicBase !== "") {
+    if (normalized === publicBase || normalized === `${publicBase}/`) return "/newsroom";
+    if (normalized.startsWith(`${publicBase}/`)) return normalized;
+    if (normalized.startsWith("/newsroom")) return normalized;
+    return `/newsroom${normalized === "/" ? "" : normalized}`;
+  }
+  if (normalized === "/" || normalized === "") return "/newsroom";
+  if (normalized.startsWith("/newsroom")) return normalized;
+  return `/newsroom${normalized}`;
+}
+
+export function newsroomHref(...segments: string[]): string {
+  const suffix = segments.filter(Boolean).join("/");
+  const publicBase = getPublicNewsroomBasePath();
+  if (!suffix) return publicBase || "/";
+  return publicBase ? `${publicBase}/${suffix}` : `/${suffix}`;
+}

package/lib/newsroom-card-layout.ts

@@ -0,0 +1,102 @@
+export type NewsroomCardSpan = "1x1" | "2x1" | "1x2" | "2x2" | "3x1" | "3x2";
+
+export type NewsroomCardTemplateRole = "lead" | "priority" | "secondary" | "tall" | "wide" | "wideFeature" | "standard";
+
+type NewsroomCardTemplateInput = {
+  mode: "desk" | "overview";
+  index: number;
+  bodyLength?: number;
+  isUrgent?: boolean;
+  qualityRating?: number | null;
+  sectionKey?: "assignments" | "messages" | "references" | string;
+  title?: string | null;
+  updatedAt?: string | null;
+};
+
+type NewsroomCardTemplate = {
+  role: NewsroomCardTemplateRole;
+  span: NewsroomCardSpan;
+};
+
+export function resolveNewsroomCardTemplate({
+  bodyLength = 0,
+  index,
+  isUrgent = false,
+  mode,
+  qualityRating,
+  sectionKey,
+  title,
+}: NewsroomCardTemplateInput): NewsroomCardTemplate {
+  if (mode === "overview") {
+    if (index === 0) return { role: "lead", span: "2x2" };
+    if (index === 3) return { role: "secondary", span: "2x1" };
+    return { role: "standard", span: "1x1" };
+  }
+  if (sectionKey === "references") {
+    return resolveReferenceDeskTemplate({
+      bodyLength,
+      index,
+      isUrgent,
+      qualityRating,
+      title: title ?? "",
+    });
+  }
+  if (index === 0 || isUrgent && index < 3) return { role: "priority", span: "2x1" };
+  if (bodyLength > 180 || index > 0 && index % 7 === 0) return { role: "tall", span: "1x2" };
+  if (index > 0 && index % 11 === 0) return { role: "secondary", span: "2x1" };
+  return { role: "standard", span: "1x1" };
+}
+
+function resolveReferenceDeskTemplate({
+  bodyLength,
+  index,
+  isUrgent,
+  qualityRating,
+  title,
+}: {
+  bodyLength: number;
+  index: number;
+  isUrgent: boolean;
+  qualityRating?: number | null;
+  title: string;
+}): NewsroomCardTemplate {
+  if (isLowQualityRating(qualityRating)) return { role: "standard", span: "1x1" };
+
+  const pressure = headlinePressure(title);
+  const bandSlot = index % 12;
+  const isBandLead = bandSlot === 0;
+  const isBandSecondary = bandSlot === 4 || bandSlot === 8;
+
+  if (pressure === "severe") {
+    return isBandLead
+      ? { role: "wideFeature", span: "3x2" }
+      : { role: "wide", span: "3x1" };
+  }
+  if (pressure === "high") {
+    return isBandLead || isBandSecondary
+      ? { role: "wide", span: "3x1" }
+      : { role: "secondary", span: "2x1" };
+  }
+  if (pressure === "medium" && (bandSlot === 1 || bandSlot === 5 || bandSlot === 9)) {
+    return { role: "secondary", span: "2x1" };
+  }
+  if (bodyLength > 340 && bandSlot === 7) return { role: "tall", span: "2x2" };
+  if (bodyLength > 220 && (bandSlot === 2 || bandSlot === 7 || bandSlot === 10)) return { role: "tall", span: "1x2" };
+  if (index === 0 || isUrgent && index < 3) return { role: "priority", span: "2x1" };
+  if (index > 0 && index % 11 === 0) return { role: "secondary", span: "2x1" };
+  return { role: "standard", span: "1x1" };
+}
+
+function headlinePressure(title: string): "low" | "medium" | "high" | "severe" {
+  const words = title.trim().split(/\s+/).filter(Boolean);
+  const characterCount = words.join(" ").length;
+  const longestWord = words.reduce((max, word) => Math.max(max, word.length), 0);
+  if (characterCount >= 96 || longestWord >= 24) return "severe";
+  if (characterCount >= 72 || longestWord >= 18) return "high";
+  if (characterCount >= 52 || longestWord >= 14) return "medium";
+  return "low";
+}
+
+function isLowQualityRating(value: number | null | undefined): boolean {
+  return typeof value === "number" && Number.isFinite(value) && value < 3;
+}

package/lib/newsroom-category-drilldown.ts

@@ -0,0 +1,133 @@
+import type {
+  CategorySteeringCategory,
+  SemanticRelationRecord,
+} from "./category-repository";
+import type {
+  SemanticNeighborGroup,
+  SemanticObjectSummary,
+} from "./semantic-graph";
+
+export type CategoryDrilldownContext = {
+  aliases: string[];
+  categories: CategorySteeringCategory[];
+  includeDescendants: boolean;
+  primary: CategorySteeringCategory | null;
+};
+
+type CategoryGraph = {
+  neighbors(kind: string, lineageId: string): SemanticNeighborGroup[];
+  referencesForCategory(categoryLineageId: string): SemanticObjectSummary[];
+};
+
+export function categoryLineageId(category: CategorySteeringCategory): string {
+  return category.lineageId ?? category.id;
+}
+
+export function buildCategoryDrilldownContext(categories: CategorySteeringCategory[], selection?: string | null): CategoryDrilldownContext {
+  if (!selection) return { aliases: [], categories: [], includeDescendants: false, primary: null };
+  const directMatches = uniqueCategoryRecords(categories.filter((category) => matchesCategorySelection(category, selection)));
+  const primary = directMatches[0] ?? null;
+  const selectedCategoryKey = primary?.categoryKey ?? selection;
+  const matchingCategoryKeyRecords = uniqueCategoryRecords(categories.filter((category) => category.categoryKey === selectedCategoryKey));
+  const directRecords = uniqueCategoryRecords([...directMatches, ...matchingCategoryKeyRecords]);
+  const includeDescendants = directRecords.some((category) => !category.parentCategoryKey);
+  const childRecords = includeDescendants
+    ? categories.filter((category) => category.parentCategoryKey === selectedCategoryKey)
+    : [];
+  const records = uniqueCategoryRecords([...directRecords, ...childRecords]);
+  return {
+    aliases: categoryAliasValues(records),
+    categories: records,
+    includeDescendants,
+    primary: primary ?? records[0] ?? null,
+  };
+}
+
+export function buildTopicDrilldownContext(
+  root: { category: CategorySteeringCategory; subcategorys: CategorySteeringCategory[] },
+  selected: CategorySteeringCategory,
+  categoryByUid: Map<string, CategorySteeringCategory>,
+): CategoryDrilldownContext {
+  const selectedFlatCategory = categoryByUid.get(selected.categoryKey) ?? null;
+  const directRecords = uniqueCategoryRecords([selected, selectedFlatCategory].filter((category): category is CategorySteeringCategory => Boolean(category)));
+  const includeDescendants = selected.categoryKey === root.category.categoryKey;
+  const childRecords = includeDescendants ? root.subcategorys : [];
+  const records = uniqueCategoryRecords([...directRecords, ...childRecords]);
+  return {
+    aliases: categoryAliasValues(records),
+    categories: records,
+    includeDescendants,
+    primary: directRecords[0] ?? records[0] ?? null,
+  };
+}
+
+export function referencesForCategoryContext(graph: CategoryGraph, context: CategoryDrilldownContext): SemanticObjectSummary[] {
+  return uniqueSemanticSummaries(context.aliases.flatMap((alias) => graph.referencesForCategory(alias)));
+}
+
+export function semanticNodesForCategoryContext(graph: CategoryGraph, context: CategoryDrilldownContext): SemanticObjectSummary[] {
+  return uniqueSemanticSummaries(
+    context.aliases.flatMap((alias) => graph.neighbors("category", alias))
+      .flatMap((group) => group.objects)
+      .filter((object) => object.kind === "semanticNode"),
+  );
+}
+
+export function uniqueNeighborGroupsForCategoryContext(graph: CategoryGraph, context: CategoryDrilldownContext): SemanticNeighborGroup[] {
+  const groups = new Map<string, SemanticNeighborGroup>();
+  for (const alias of context.aliases) {
+    for (const group of graph.neighbors("category", alias)) {
+      const key = `${group.direction}#${group.predicate}`;
+      const current = groups.get(key);
+      if (!current) {
+        groups.set(key, { ...group, relations: [...group.relations], objects: [...group.objects] });
+      } else {
+        current.relations = uniqueRelations([...current.relations, ...group.relations]);
+        current.objects = uniqueSemanticSummaries([...current.objects, ...group.objects]);
+      }
+    }
+  }
+  return Array.from(groups.values());
+}
+
+export function topicHref(rootCategoryKey: string, selectedCategoryKey?: string | null): string {
+  const encodedRoot = encodeURIComponent(rootCategoryKey);
+  const encodedSelected = selectedCategoryKey && selectedCategoryKey !== rootCategoryKey ? `/${encodeURIComponent(selectedCategoryKey)}` : "";
+  return `/newsroom/topics/${encodedRoot}${encodedSelected}`;
+}
+
+export function categoryDrilldownHref(section: "references" | "concepts", categoryKey: string): string {
+  return `/newsroom/${section}/${encodeURIComponent(categoryKey)}`;
+}
+
+function matchesCategorySelection(category: CategorySteeringCategory, selection: string): boolean {
+  return category.id === selection || category.lineageId === selection || category.categoryKey === selection;
+}
+
+function uniqueCategoryRecords(categories: CategorySteeringCategory[]): CategorySteeringCategory[] {
+  const records = new Map<string, CategorySteeringCategory>();
+  for (const category of categories) {
+    records.set(category.id, category);
+  }
+  return Array.from(records.values());
+}
+
+function categoryAliasValues(categories: CategorySteeringCategory[]): string[] {
+  const aliases = new Set<string>();
+  for (const category of categories) {
+    aliases.add(category.id);
+    aliases.add(category.categoryKey);
+    if (category.lineageId) aliases.add(category.lineageId);
+  }
+  return Array.from(aliases).filter(Boolean);
+}
+
+function uniqueRelations(relations: SemanticRelationRecord[]): SemanticRelationRecord[] {
+  return Array.from(new Map(relations.map((relation) => [relation.id, relation])).values());
+}
+
+function uniqueSemanticSummaries(objects: SemanticObjectSummary[]): SemanticObjectSummary[] {
+  const map = new Map<string, SemanticObjectSummary>();
+  for (const object of objects) map.set(`${object.kind}#${object.lineageId}`, object);
+  return Array.from(map.values()).sort((left, right) => left.label.localeCompare(right.label));
+}