@anthusai/papyrus 0.0.0 → 1.0.0-next.2

package/lib/newsroom-knowledge-query-request.ts

@@ -0,0 +1,51 @@
+export type NewsroomKnowledgeQueryAnchor = {
+  kind: "assignment" | "category" | "categorySet" | "item" | "message" | "newsroomSection" | "reference" | "semanticNode";
+  id: string;
+  lineageId?: string | null;
+};
+
+export type NewsroomKnowledgeQueryTarget = {
+  anchor: NewsroomKnowledgeQueryAnchor;
+  title: string;
+  subtitle?: string | null;
+};
+
+type BuildKnowledgeQueryInputOptions = {
+  profile?: "researcher" | "reporter" | "editor" | "reviewer" | "chat";
+  semanticSearch?: boolean;
+};
+
+export function buildNewsroomKnowledgeQueryInput(
+  target: NewsroomKnowledgeQueryTarget | null,
+  semanticText: string,
+  maxTokens: number,
+  options: BuildKnowledgeQueryInputOptions = {},
+): Record<string, unknown> {
+  const request: Record<string, unknown> = {
+    semanticQuery: semanticText.trim(),
+    scope: {
+      depth: 1,
+      topK: target ? 18 : 24,
+      relatedRecordLimit: target ? 8 : 10,
+      semanticSearch: options.semanticSearch ?? true,
+    },
+    profile: options.profile ?? "editor",
+    ranking: {
+      profile: "balanced",
+      diversity: target ? "balanced" : "broad",
+    },
+    output: {
+      format: "markdown",
+      maxTokens,
+    },
+  };
+  if (target) {
+    const anchor: Record<string, unknown> = {
+      kind: target.anchor.kind,
+      id: target.anchor.id,
+    };
+    if (target.anchor.lineageId) anchor.lineageId = target.anchor.lineageId;
+    request.anchors = [anchor];
+  }
+  return request;
+}

package/lib/newsroom-list-selection.ts

@@ -0,0 +1,42 @@
+import { cn } from "./utils";
+
+/** List-row selection: dark copy on moss/paper tint in light mode; light copy on wash in dark mode. Never invert to primary-foreground. */
+export const NEWSROOM_LIST_ROW_BASE =
+  "w-full rounded-xl border bg-card p-4 text-left text-foreground transition-colors";
+
+export const NEWSROOM_LIST_ROW_INACTIVE =
+  "border-border hover:border-primary/30 hover:bg-primary/5";
+
+export const NEWSROOM_LIST_ROW_ACTIVE =
+  "border-primary/40 bg-primary/10 text-foreground ring-1 ring-primary/15";
+
+export const NEWSROOM_INBOX_ROW_BASE =
+  "flex items-start gap-3 rounded-xl border bg-card p-3 text-foreground transition-colors";
+
+export const NEWSROOM_INBOX_ROW_INACTIVE =
+  "border-border hover:border-primary/30 hover:bg-primary/5";
+
+export const NEWSROOM_INBOX_ROW_ACTIVE =
+  "border-primary/40 bg-primary/10 text-foreground ring-1 ring-primary/15";
+
+export const NEWSROOM_SIDEBAR_NAV_ACTIVE =
+  "bg-primary/10 text-foreground shadow-none hover:bg-primary/15";
+
+export const NEWSROOM_SIDEBAR_NAV_INACTIVE =
+  "text-muted-foreground hover:bg-muted/50 hover:text-foreground";
+
+export function newsroomListRowClassName(active: boolean, className?: string): string {
+  return cn(
+    NEWSROOM_LIST_ROW_BASE,
+    active ? NEWSROOM_LIST_ROW_ACTIVE : NEWSROOM_LIST_ROW_INACTIVE,
+    className,
+  );
+}
+
+export function newsroomInboxRowClassName(active: boolean, className?: string): string {
+  return cn(
+    NEWSROOM_INBOX_ROW_BASE,
+    active ? NEWSROOM_INBOX_ROW_ACTIVE : NEWSROOM_INBOX_ROW_INACTIVE,
+    className,
+  );
+}

package/lib/newsroom-nav.ts

@@ -0,0 +1,42 @@
+import { newsroomHref, toPublicNewsroomPath } from "./newsroom-base-path";
+
+export type NewsroomNavTabId =
+  | "overview"
+  | "messages"
+  | "insights"
+  | "assignments"
+  | "references"
+  | "topics"
+  | "concepts"
+  | "administration"
+  | "search"
+  | "desks";
+
+export type NewsroomNavItem = {
+  id: NewsroomNavTabId;
+  label: string;
+  detail: string;
+  href: string;
+  mobilePrimary?: boolean;
+};
+
+export const NEWSROOM_OPS_NAV: NewsroomNavItem[] = [
+  { id: "overview", label: "Overview", detail: "Desk home", href: newsroomHref(), mobilePrimary: true },
+  { id: "assignments", label: "Assignments", detail: "Work queue", href: newsroomHref("assignments"), mobilePrimary: true },
+  { id: "references", label: "References", detail: "Knowledge base", href: newsroomHref("references"), mobilePrimary: true },
+  { id: "messages", label: "Messages", detail: "Forum", href: newsroomHref("messages") },
+  { id: "insights", label: "Insights", detail: "Research threads", href: newsroomHref("insights") },
+  { id: "topics", label: "Topics", detail: "Taxonomy", href: newsroomHref("topics"), mobilePrimary: true },
+  { id: "concepts", label: "Concepts", detail: "Ontology", href: newsroomHref("concepts") },
+  { id: "administration", label: "Administration", detail: "Users & policies", href: newsroomHref("administration") },
+];
+
+export const NEWSROOM_MOBILE_PRIMARY_NAV = NEWSROOM_OPS_NAV.filter((item) => item.mobilePrimary);
+
+export function getNewsroomNavHref(href: string, demo?: boolean): string {
+  const path = toPublicNewsroomPath(href);
+  if (!demo) return path;
+  const url = new URL(path, "http://localhost");
+  url.searchParams.set("demo", "1");
+  return `${url.pathname}${url.search}`;
+}

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",
+]);