@anthusai/papyrus 0.0.0 → 1.0.0-next.10

package/lib/newsroom-references.ts

@@ -0,0 +1,116 @@
+import type { ReferenceRecord } from "./category-repository";
+import { normalizeReferenceCurationStatus } from "./reference-policy";
+
+export type ReferenceCurationAction = "accept" | "reject" | "archive";
+
+export type ReferenceStatusFilter = "all" | "pending" | "accepted" | "rejected" | "archived";
+
+export function referenceLineageId(reference: ReferenceRecord): string {
+  return reference.lineageId ?? reference.id;
+}
+
+export function normalizeReferenceStatus(status: string | null | undefined): string {
+  return normalizeReferenceCurationStatus(status);
+}
+
+function referenceSortDate(reference: ReferenceRecord): string {
+  return reference.sourcePublishedAt
+    ?? reference.sourceUpdatedAt
+    ?? reference.retrievedAt
+    ?? reference.importedAt
+    ?? reference.updatedAt
+    ?? "";
+}
+
+export function compareReferencesByRecency(left: ReferenceRecord, right: ReferenceRecord): number {
+  const dateDiff = referenceSortDate(right).localeCompare(referenceSortDate(left));
+  if (dateDiff !== 0) return dateDiff;
+  return (left.title ?? left.externalItemId).localeCompare(right.title ?? right.externalItemId);
+}
+
+function compareReferencesForCanonicalChoice(left: ReferenceRecord, right: ReferenceRecord): number {
+  const leftCurrent = left.versionState === "current" ? 1 : 0;
+  const rightCurrent = right.versionState === "current" ? 1 : 0;
+  if (leftCurrent !== rightCurrent) return rightCurrent - leftCurrent;
+
+  const leftVersion = Number.isFinite(left.versionNumber) ? Number(left.versionNumber) : 0;
+  const rightVersion = Number.isFinite(right.versionNumber) ? Number(right.versionNumber) : 0;
+  if (leftVersion !== rightVersion) return rightVersion - leftVersion;
+
+  return compareReferencesByRecency(left, right);
+}
+
+export function selectCanonicalReferenceRecords(references: ReferenceRecord[]): ReferenceRecord[] {
+  const byLineage = new Map<string, ReferenceRecord>();
+  for (const reference of references) {
+    const key = referenceLineageId(reference);
+    const current = byLineage.get(key);
+    if (!current || compareReferencesForCanonicalChoice(reference, current) < 0) {
+      byLineage.set(key, reference);
+    }
+  }
+  return Array.from(byLineage.values()).sort(compareReferencesByRecency);
+}
+
+export function selectedReferenceRecordByLineage(
+  references: ReferenceRecord[],
+  requestedLineageId: string | null | undefined,
+): ReferenceRecord | null {
+  if (!requestedLineageId) return null;
+  const lineageMatches = references.filter((reference) => referenceLineageId(reference) === requestedLineageId);
+  if (!lineageMatches.length) return null;
+  return lineageMatches.reduce((best, current) => (
+    compareReferencesForCanonicalChoice(current, best) < 0 ? current : best
+  ));
+}
+
+export function countReferencesByStatus(references: ReferenceRecord[]): Record<string, number> {
+  const counts: Record<string, number> = {};
+  for (const reference of references) {
+    const status = normalizeReferenceStatus(reference.curationStatus);
+    counts[status] = (counts[status] ?? 0) + 1;
+  }
+  return counts;
+}
+
+export function filterReferencesByStatus(
+  references: ReferenceRecord[],
+  statusFilter: ReferenceStatusFilter,
+): ReferenceRecord[] {
+  const canonical = selectCanonicalReferenceRecords(references);
+  if (statusFilter === "all") return canonical;
+  return canonical.filter((reference) => normalizeReferenceStatus(reference.curationStatus) === statusFilter);
+}
+
+export function formatReferenceListDate(reference: ReferenceRecord): string {
+  const value = referenceSortDate(reference);
+  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 referenceDisplayTitle(reference: ReferenceRecord): string {
+  return reference.title?.trim() || reference.externalItemId;
+}
+
+export function referenceStatusLabel(status: string): string {
+  if (status === "accepted") return "Accepted";
+  if (status === "rejected") return "Rejected";
+  if (status === "archived") return "Archived";
+  return "Pending";
+}
+
+export function referenceStatusBadgeVariant(
+  status: string,
+): "default" | "secondary" | "outline" | "muted" {
+  if (status === "accepted") return "default";
+  if (status === "rejected") return "outline";
+  if (status === "archived") return "secondary";
+  return "muted";
+}

package/lib/newsroom-sections.ts

@@ -0,0 +1,52 @@
+import type { NewsroomSectionRecord } from "./category-repository";
+import { getNewsroomNavHref } from "./newsroom-nav";
+
+const SECTION_SHORT_TITLE_FALLBACKS: Record<string, string> = {
+  news: "News",
+  business: "Business",
+  technology: "Technology",
+  science: "Science",
+  methods: "Methods",
+  history: "History",
+  opinion: "Opinion",
+  world: "World",
+  arts: "Arts",
+  sports: "Sports",
+  education: "Education",
+  health: "Health",
+  security: "Security",
+  "law-policy": "Law & Policy",
+  labor: "Labor",
+  "field-notes": "Field Notes",
+  "strangler-control": "Host encirclement",
+  "mycelial-signals": "Network routing",
+};
+
+export function normalizeNewsroomSectionType(value: string | null | undefined): "canonical" | "floating" {
+  return value === "floating" || value === "rotating" ? "floating" : "canonical";
+}
+
+export function isEnabledNewsroomSection(section: NewsroomSectionRecord): boolean {
+  return section.enabled !== false && section.enabledStatus !== "disabled";
+}
+
+export function sortNewsroomSections(sections: NewsroomSectionRecord[]): NewsroomSectionRecord[] {
+  return [...sections].sort((left, right) => {
+    const typeDiff = (normalizeNewsroomSectionType(left.type) === "canonical" ? 0 : 1)
+      - (normalizeNewsroomSectionType(right.type) === "canonical" ? 0 : 1);
+    if (typeDiff !== 0) return typeDiff;
+    const orderDiff = (left.sortOrder ?? 999999) - (right.sortOrder ?? 999999);
+    if (orderDiff !== 0) return orderDiff;
+    return left.title.localeCompare(right.title);
+  });
+}
+
+export function displayNewsroomSectionShortTitle(section: NewsroomSectionRecord): string {
+  const explicit = section.shortTitle?.trim();
+  if (explicit) return explicit;
+  return SECTION_SHORT_TITLE_FALLBACKS[section.id] ?? section.id.replace(/-/g, " ");
+}
+
+export function buildNewsroomSectionHref(sectionId: string, demo?: boolean): string {
+  return getNewsroomNavHref(`/newsroom/sections/${encodeURIComponent(sectionId)}`, demo);
+}

package/lib/newsroom-topics.ts

@@ -0,0 +1,118 @@
+import type { CategorySteeringProposal } from "./category-repository";
+
+export type TopicProposalReviewAction = "accept" | "reject" | "defer" | "edit";
+
+export type TopicProposalStatusFilter = "all" | "proposed" | "deferred" | "reviewed";
+
+const TOPIC_PROPOSAL_BLOCKED_APPLY_KINDS = new Set([
+  "merge-category",
+  "merge-categories",
+  "split-category",
+  "archive-category",
+  "deprecate-category",
+]);
+
+export function isCategoryTopicProposal(proposal: CategorySteeringProposal): boolean {
+  return proposal.steeringDomain === "category";
+}
+
+export function filterTopicProposals(
+  proposals: CategorySteeringProposal[],
+  statusFilter: TopicProposalStatusFilter,
+): CategorySteeringProposal[] {
+  const categoryProposals = proposals.filter(isCategoryTopicProposal);
+  if (statusFilter === "all") return categoryProposals;
+  if (statusFilter === "reviewed") {
+    return categoryProposals.filter((proposal) => (
+      proposal.status === "accepted" || proposal.status === "rejected"
+    ));
+  }
+  return categoryProposals.filter((proposal) => proposal.status === statusFilter);
+}
+
+export function countTopicProposalsByStatus(
+  proposals: CategorySteeringProposal[],
+): Record<TopicProposalStatusFilter, number> {
+  const categoryProposals = proposals.filter(isCategoryTopicProposal);
+  return {
+    all: categoryProposals.length,
+    proposed: categoryProposals.filter((proposal) => proposal.status === "proposed").length,
+    deferred: categoryProposals.filter((proposal) => proposal.status === "deferred").length,
+    reviewed: categoryProposals.filter((proposal) => (
+      proposal.status === "accepted" || proposal.status === "rejected"
+    )).length,
+  };
+}
+
+export function compareTopicProposals(
+  left: CategorySteeringProposal,
+  right: CategorySteeringProposal,
+): number {
+  const statusWeight = new Map([
+    ["proposed", 0],
+    ["deferred", 1],
+    ["accepted", 2],
+    ["rejected", 3],
+  ]);
+  const statusDiff = (statusWeight.get(left.status) ?? 9) - (statusWeight.get(right.status) ?? 9);
+  if (statusDiff !== 0) return statusDiff;
+  const dateDiff = (right.proposedAt ?? right.updatedAt ?? "").localeCompare(left.proposedAt ?? left.updatedAt ?? "");
+  if (dateDiff !== 0) return dateDiff;
+  return proposalDisplayTitle(left).localeCompare(proposalDisplayTitle(right));
+}
+
+export function sortTopicProposals(proposals: CategorySteeringProposal[]): CategorySteeringProposal[] {
+  return [...proposals].sort(compareTopicProposals);
+}
+
+export function proposalDisplayTitle(proposal: CategorySteeringProposal): string {
+  return proposal.displayName?.trim() || proposal.title?.trim() || proposal.categoryKey || proposal.id;
+}
+
+export function proposalStatusLabel(status: string): string {
+  if (status === "accepted") return "Accepted";
+  if (status === "rejected") return "Rejected";
+  if (status === "deferred") return "Deferred";
+  return "Proposed";
+}
+
+export function proposalStatusBadgeVariant(
+  status: string,
+): "default" | "secondary" | "outline" | "muted" {
+  if (status === "accepted") return "default";
+  if (status === "rejected") return "outline";
+  if (status === "deferred") return "secondary";
+  return "muted";
+}
+
+export function formatProposalListDate(proposal: CategorySteeringProposal): string {
+  const value = proposal.proposedAt ?? proposal.reviewedAt ?? proposal.updatedAt ?? "";
+  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 selectedTopicProposalById(
+  proposals: CategorySteeringProposal[],
+  proposalId: string | null | undefined,
+): CategorySteeringProposal | null {
+  if (!proposalId) return null;
+  return proposals.find((proposal) => proposal.id === proposalId) ?? null;
+}
+
+export function topicProposalReviewBlockedReason(
+  proposal: CategorySteeringProposal,
+  action: TopicProposalReviewAction,
+): string | null {
+  if ((action === "accept" || action === "edit") && TOPIC_PROPOSAL_BLOCKED_APPLY_KINDS.has(proposal.proposalKind)) {
+    return `${proposal.proposalKind} apply is not implemented yet.`;
+  }
+  return null;
+}
+

package/lib/papyrus-object-kinds.ts

@@ -0,0 +1,24 @@
+export type PapyrusObjectKind =
+  | "assignment"
+  | "category"
+  | "categorySet"
+  | "item"
+  | "message"
+  | "newsroomSection"
+  | "reference"
+  | "semanticNode"
+  | "semanticRelation"
+  | "steeringProposal";
+
+export const PAPYRUS_OBJECT_KINDS = new Set<PapyrusObjectKind>([
+  "assignment",
+  "category",
+  "categorySet",
+  "item",
+  "message",
+  "newsroomSection",
+  "reference",
+  "semanticNode",
+  "semanticRelation",
+  "steeringProposal",
+]);