@anthusai/papyrus 2.0.0-next.8 → 2.0.0-next.80

package/components/automation-panel.tsx

@@ -0,0 +1,49 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { loadAutomationOverview, runAutomationNow } from "../lib/automation-client";
+import { FIXTURE_AUTOMATION_OVERVIEW } from "../lib/automation-fixture";
+import type { AutomationResult } from "../lib/automation-overview";
+import { AutomationView } from "./automation-view";
+
+const REFRESH_MILLISECONDS = 60_000;
+
+/** Administration, Automation: loads the records and their recent runs, and refreshes each minute. */
+export function AutomationPanel({ isDemo }: { isDemo: boolean }) {
+  const [result, setResult] = useState<AutomationResult | null>(null);
+  const [selectedId, setSelectedId] = useState<string | null>(null);
+
+  useEffect(() => {
+    if (isDemo) {
+      setResult(FIXTURE_AUTOMATION_OVERVIEW);
+      return;
+    }
+    let live = true;
+    const refresh = async () => {
+      try {
+        const next = await loadAutomationOverview();
+        if (live) setResult(next);
+      } catch {
+        if (live) setResult({ state: "unavailable" });
+      }
+    };
+    void refresh();
+    const timer = window.setInterval(() => void refresh(), REFRESH_MILLISECONDS);
+    return () => {
+      live = false;
+      window.clearInterval(timer);
+    };
+  }, [isDemo]);
+
+  const runNow = isDemo ? undefined : async (automationId: string, input: Record<string, unknown> | null) => {
+    const outcome = await runAutomationNow(automationId, input);
+    try {
+      setResult(await loadAutomationOverview());   // show the new run without waiting for the minute
+    } catch {
+      /* the next refresh will */
+    }
+    return outcome;
+  };
+
+  return <AutomationView result={result} selectedId={selectedId} onSelect={setSelectedId} demo={isDemo} onRunNow={runNow} />;
+}

package/components/automation-run-now.tsx

@@ -0,0 +1,97 @@
+"use client";
+
+import { useState } from "react";
+import {
+  atATimeText,
+  inputTemplateText,
+  parseRunInput,
+  runNowMessage,
+  type AutomationRecord,
+  type RunNowResult,
+} from "../lib/automation-overview";
+
+export type RunNowPhase = "idle" | "confirming" | "running" | "done";
+
+/**
+ * "Run now": a button, then a confirm step that says what will start and, when the record's input names
+ * placeholders for an item, asks for the input of this run. Starting costs money (the procedure calls a model),
+ * so nothing starts on the first click. `initialPhase` and `initialMessage` exist so every step renders from a test.
+ */
+export function RunNowControl({
+  record,
+  demo = false,
+  onRun,
+  initialPhase = "idle",
+  initialMessage = null,
+}: {
+  record: Pick<AutomationRecord, "id" | "title" | "procedureKey" | "runNow" | "limits">;
+  demo?: boolean;
+  onRun?: (automationId: string, input: Record<string, unknown> | null) => Promise<RunNowResult>;
+  initialPhase?: RunNowPhase;
+  initialMessage?: string | null;
+}) {
+  const [phase, setPhase] = useState<RunNowPhase>(initialPhase);
+  const [message, setMessage] = useState<string | null>(initialMessage);
+  const [text, setText] = useState(record.runNow.needsInput ? inputTemplateText(record.runNow.inputNames) : "");
+  const [problem, setProblem] = useState<string | null>(null);
+
+  if (!record.runNow.available) {
+    return (
+      <p className="news-desk-delegation-note" data-automation-run-now-unavailable>
+        Run now is not available: {record.runNow.reason === "disabled" ? "the automation is disabled. Enable it first." : (record.runNow.reason ?? "not supported")}.
+      </p>
+    );
+  }
+
+  async function confirm() {
+    const parsed = parseRunInput(text);
+    if (!parsed.ok) {
+      setProblem(parsed.message);
+      return;
+    }
+    if (record.runNow.needsInput && parsed.value === null) {
+      setProblem("This automation's input names an item, so give the input for this run.");
+      return;
+    }
+    setProblem(null);
+    setPhase("running");
+    try {
+      const result = onRun ? await onRun(record.id, parsed.value) : ({ state: "unavailable" } as RunNowResult);
+      setMessage(runNowMessage(result));
+    } catch {
+      setMessage(runNowMessage({ state: "unavailable" }));
+    }
+    setPhase("done");
+  }
+
+  return (
+    <div data-automation-run-now={record.id} data-run-now-phase={phase}>
+      {phase === "idle" || phase === "done" ? (
+        <button type="button" data-automation-run-now-start onClick={() => { setMessage(null); setPhase("confirming"); }}>
+          Run now
+        </button>
+      ) : null}
+      {phase === "confirming" || phase === "running" ? (
+        <div role="group" aria-label={`Confirm Run now for ${record.title}`} data-automation-run-now-confirm>
+          <p>
+            Run <strong>{record.procedureKey}</strong> now? It calls a model, which costs money, and it counts against the
+            limit ({atATimeText(record.limits)}). The run is linked to this automation.
+          </p>
+          {demo ? <p className="news-desk-delegation-note">This is the demo, so nothing will start.</p> : null}
+          <label>
+            Input for this run{record.runNow.needsInput ? " (required)" : " (optional; blank uses the record's input)"}
+            <textarea rows={4} value={text} onChange={(event) => setText(event.target.value)} disabled={phase === "running"} data-automation-run-now-input />
+          </label>
+          {problem ? <p role="alert" data-automation-run-now-problem>{problem}</p> : null}
+          <button type="button" onClick={() => void confirm()} disabled={phase === "running" || demo} data-automation-run-now-confirm-button>
+            {phase === "running" ? "Starting…" : "Confirm: start the run"}
+          </button>{" "}
+          <button type="button" onClick={() => { setPhase("idle"); setProblem(null); }} disabled={phase === "running"} data-automation-run-now-cancel>
+            Cancel
+          </button>
+        </div>
+      ) : null}
+      {message ? <p role="status" data-automation-run-now-message>{message}</p> : null}
+    </div>
+  );
+}

package/components/automation-view.tsx

@@ -0,0 +1,192 @@
+import Link from "next/link";
+import { RunNowControl } from "./automation-run-now";
+import {
+  ENABLED_NOTE,
+  OUTSIDE_NOTICE,
+  atATimeText,
+  costText,
+  durationText,
+  enabledText,
+  formatUtc,
+  linkText,
+  noticeText,
+  proceduresHref,
+  statusMark,
+  statusText,
+  storyHref,
+  triggerText,
+  whoText,
+  type AutomationOutsideRun,
+  type AutomationRecord,
+  type AutomationResult,
+  type AutomationRun,
+  type RunNowResult,
+} from "../lib/automation-overview";
+
+function Message({ title, children, kind }: { title: string; children?: React.ReactNode; kind: string }) {
+  return (
+    <div className="category-steering-empty" role={kind === "loading" ? "status" : "alert"} data-automation-state={kind}>
+      <strong>{title}</strong>
+      {children ? <p>{children}</p> : null}
+    </div>
+  );
+}
+
+function RunLine({ run, demo }: { run: AutomationRun; demo: boolean }) {
+  return (
+    <li data-automation-run={run.runId ?? run.sourceId ?? "unlinked"} data-run-status={run.status ?? "unknown"}>
+      <strong>{formatUtc(run.startedAt)}</strong>
+      <span><span aria-hidden="true">{statusMark(run.status)} </span>Status: {statusText(run.status)} &middot; {durationText(run.durationSeconds)}</span>
+      <span>{whoText(run)}</span>
+      {run.reason ? <span data-automation-run-reason>Reason: {run.reason}</span> : null}
+      {run.error ? <span data-automation-run-error>Error: {run.error}</span> : null}
+      <span>
+        {run.runId ? <>Run {run.runId} (<Link href={proceduresHref(demo)}>Procedures</Link>)</> : run.triggerStatus === "started" ? "Run record not linked yet" : "No run record"}
+        {run.runRecord === "missing" ? " (the run record was not found)" : ""}
+        {run.runRecord === "unavailable" ? " (the run record could not be read)" : ""}
+      </span>
+      <span>
+        {run.storyId ? <>Story: <Link href={storyHref(run.storyId, demo)} data-automation-story-link>{run.storyTitle ?? run.storyId}</Link></> : "Story: none recorded"}
+      </span>
+      <span data-automation-run-cost data-over-budget={run.overBudget || undefined}>
+        <span aria-hidden="true">{run.overBudget ? "! " : ""}</span>{costText(run)}
+      </span>
+    </li>
+  );
+}
+
+function OutsideRunLine({ run, demo }: { run: AutomationOutsideRun; demo: boolean }) {
+  return (
+    <li data-automation-outside-run={run.runId ?? "unlinked"} data-run-status={run.status ?? "unknown"}>
+      <strong>{formatUtc(run.startedAt)}</strong>
+      <span><span aria-hidden="true">{statusMark(run.status)} </span>Status: {statusText(run.status)} &middot; {durationText(run.durationSeconds)}</span>
+      <span>Started by: {run.requestedBy ?? "unknown"}</span>
+      {run.error ? <span data-automation-run-error>Error: {run.error}</span> : null}
+      <span>{run.runId ? <>Run {run.runId} (<Link href={proceduresHref(demo)}>Procedures</Link>)</> : "No run id"}</span>
+      <span>
+        {run.storyId ? <>Story: <Link href={storyHref(run.storyId, demo)}>{run.storyTitle ?? run.storyId}</Link></> : "Story: none recorded"}
+      </span>
+      <span data-automation-run-cost>{costText({ ...run, budgetUsd: null })}</span>
+    </li>
+  );
+}
+
+function Detail({ record, demo, onRunNow }: { record: AutomationRecord; demo: boolean; onRunNow?: RunNowHandler }) {
+  const notice = noticeText(record.notice);
+  return (
+    <article className="news-desk-doctrine-card" data-automation-detail={record.id}>
+      <div className="news-desk-doctrine-card__header"><div><h3>{record.title}</h3><span>{record.description ?? record.id}</span></div></div>
+      <dl className="news-desk-monitoring__usage">
+        <div><dt>Trigger</dt><dd>{triggerText(record.trigger)}{record.supported ? "" : ` (${record.supportNote ?? "not yet supported"})`}</dd></div>
+        <div><dt>Procedure</dt><dd>{record.procedureKey}</dd></div>
+        <div><dt>Input</dt><dd>{Object.keys(record.inputTemplate).length ? Object.entries(record.inputTemplate).map(([name, template]) => `${name} = ${template}`).join("; ") : "none"}</dd></div>
+        <div><dt>Enabled</dt><dd>{enabledText(record)} ({ENABLED_NOTE})</dd></div>
+        <div><dt>Limits</dt><dd>timeout {record.limits.timeoutSeconds ?? "?"} s, {atATimeText(record.limits)}{record.limits.budgetUsdPerRun !== undefined ? `, about $${record.limits.budgetUsdPerRun} per run, advisory` : ""} ({record.limitsNote})</dd></div>
+        <div><dt>Router</dt><dd data-automation-link={record.link?.state ?? "unchecked"}>{linkText(record.link)}</dd></div>
+      </dl>
+      {notice ? <p className="news-desk-delegation-note" data-automation-notice>{notice}</p> : null}
+      <RunNowControl record={record} demo={demo} onRun={onRunNow} />
+      <h4>Recent runs</h4>
+      {record.runs.length ? (
+        <ul className="news-desk-monitoring__list" data-automation-runs>
+          {record.runs.map((run) => <RunLine key={run.runId ?? `${run.sourceId}-${run.startedAt}`} run={run} demo={demo} />)}
+        </ul>
+      ) : <p data-automation-no-runs>No runs yet.</p>}
+      {record.skippedAlreadyHadReference > 0 ? (
+        <p className="news-desk-delegation-note" data-automation-skipped>
+          {record.skippedAlreadyHadReference} {record.skippedAlreadyHadReference === 1 ? "item was" : "items were"} not started because the Reference already existed.
+        </p>
+      ) : null}
+      {record.outsideRuns.length || record.outsideNotice ? (
+        <>
+          <h4>Started outside this automation</h4>
+          <p className="news-desk-delegation-note">Other runs of {record.procedureKey} that this automation did not start.</p>
+          {record.outsideNotice ? <p className="news-desk-delegation-note" data-automation-notice>{OUTSIDE_NOTICE}</p> : null}
+          {record.outsideRuns.length ? (
+            <ul className="news-desk-monitoring__list" data-automation-outside-runs>
+              {record.outsideRuns.map((run) => <OutsideRunLine key={run.runId ?? run.startedAt ?? "run"} run={run} demo={demo} />)}
+            </ul>
+          ) : null}
+        </>
+      ) : null}
+    </article>
+  );
+}
+
+function ListItem({ record, selected, onSelect }: { record: AutomationRecord; selected: boolean; onSelect: (id: string) => void }) {
+  const last = record.lastRun;
+  return (
+    <li data-automation={record.id}>
+      <div>
+        <strong>{record.title}</strong>
+        <span>{triggerText(record.trigger)}{record.supported ? "" : ` (${record.supportNote ?? "not yet supported"})`}</span>
+      </div>
+      <span>Procedure: {record.procedureKey}</span>
+      <span>{enabledText(record)} ({ENABLED_NOTE})</span>
+      <span data-automation-last-run>
+        Last run: <span aria-hidden="true">{statusMark(last?.status)} </span>{statusText(last?.status)}{last ? `, ${formatUtc(last.startedAt)}` : ""}
+      </span>
+      <button type="button" aria-pressed={selected} data-automation-select={record.id} onClick={() => onSelect(record.id)}>
+        {selected ? "Showing runs" : "Show runs"}
+      </button>
+    </li>
+  );
+}
+
+/** Presentation only: the panel fetches, this renders any result, so every state is testable from fixtures. */
+export type RunNowHandler = (automationId: string, input: Record<string, unknown> | null) => Promise<RunNowResult>;
+
+export function AutomationView({
+  result,
+  selectedId,
+  onSelect,
+  demo = false,
+  onRunNow,
+}: {
+  result: AutomationResult | null;
+  selectedId: string | null;
+  onSelect: (id: string) => void;
+  demo?: boolean;
+  onRunNow?: RunNowHandler;
+}) {
+  let body: React.ReactNode;
+  if (result === null) {
+    body = <Message kind="loading" title="Loading automations" />;
+  } else if ("error" in result) {
+    body = result.error === "forbidden"
+      ? <Message kind="forbidden" title="Automations are for editors and admins">Your account does not have access to this page. Ask an admin for the editor role.</Message>
+      : <Message kind="error" title="Automations could not be read">The request was not understood. Reload the page.</Message>;
+  } else if (result.state === "unavailable") {
+    body = <Message kind="unavailable" title="Automations could not be read right now">Nothing is affected. Try again in a minute.</Message>;
+  } else if (result.state === "empty") {
+    body = <Message kind="empty" title="No automations yet">An operator creates one with <code>papyrus automations create</code>. Nothing is configured to run on its own from this page.</Message>;
+  } else {
+    const selected = result.automations.find((record) => record.id === selectedId) ?? (result.automations.length === 1 ? result.automations[0] : null);
+    body = (
+      <>
+        <article className="news-desk-doctrine-card" data-automation-section="list">
+          <div className="news-desk-doctrine-card__header"><div><h3>Automations</h3><span>What starts a procedure by itself</span></div></div>
+          <ul className="news-desk-monitoring__list">
+            {result.automations.map((record) => <ListItem key={record.id} record={record} selected={selected?.id === record.id} onSelect={onSelect} />)}
+          </ul>
+          {result.monitoring === "not_configured" ? <p className="news-desk-delegation-note" data-automation-notice>{noticeText("monitoring_not_configured")}</p> : null}
+        </article>
+        {selected ? <Detail record={selected} demo={demo} onRunNow={onRunNow} /> : <p className="news-desk-delegation-note" data-automation-pick>Choose an automation to see its recent runs.</p>}
+      </>
+    );
+  }
+  return (
+    <div data-news-desk-admin-panel="automations">
+      <article className="news-desk-doctrine-card">
+        <div className="news-desk-doctrine-card__header">
+          <div>
+            <h3>Automation</h3>
+            <span>Procedures that start on their own. Editors and admins can run one now; an operator changes the settings with the command line.</span>
+          </div>
+        </div>
+        {result && "asOf" in result ? <p className="news-desk-delegation-note" data-automation-as-of>As of {formatUtc(result.asOf)}. Enabled: {ENABLED_NOTE}.</p> : null}
+      </article>
+      {body}
+    </div>
+  );
+}

package/components/editorial-checks-admin-panel.tsx

@@ -12,6 +12,7 @@ import {
   draftQuestions,
   importStarterPack,
   listPolicies,
+  listStarterPacks,
   loadSettings,
   recalibrate,
   savePolicy,
@@ -19,9 +20,9 @@ import {
   tryPolicy,
   type EditorialPolicyRecord,
   type EditorialSettings,
+  type StarterPackSummary,
 } from "../lib/editorial-checks-client";
 
-const STARTER_PACK = "ai-writing-tells";
 const POLICY_KEY = /^[a-z0-9][a-z0-9._-]*$/;
 
 type Draft = {
@@ -63,8 +64,8 @@ function lines(text: string): string[] {
   return text.split("\n").map((line) => line.trim()).filter(Boolean);
 }
 
-/** The policy as Limatus sees it (its key is the policy id). Throws on invalid detector JSON. */
-function limatusPolicy(draft: Draft): Record<string, unknown> {
+/** The policy as Humanus sees it (its key is the policy id). Throws on invalid detector JSON. */
+function humanusPolicy(draft: Draft): Record<string, unknown> {
   const detectors = JSON.parse(draft.detectorsText || "[]") as unknown;
   if (!Array.isArray(detectors)) throw new Error("Detectors must be a JSON list.");
   const violates = lines(draft.violatesText);
@@ -87,6 +88,8 @@ export function EditorialChecksAdminPanel() {
   const [settings, setSettings] = useState<EditorialSettings>(DEFAULT_EDITORIAL_SETTINGS);
   const [settingsExist, setSettingsExist] = useState(false);
   const [draft, setDraft] = useState<Draft | null>(null);
+  const [starterPacks, setStarterPacks] = useState<StarterPackSummary[]>([]);
+  const [starterPack, setStarterPack] = useState<string>("");
   const [message, setMessage] = useState<string | null>(null);
   const [working, setWorking] = useState<string | null>(null);
   const [tryText, setTryText] = useState("");
@@ -94,7 +97,9 @@ export function EditorialChecksAdminPanel() {
 
   const refresh = useCallback(async () => {
     try {
-      const [loadedPolicies, loadedSettings] = await Promise.all([listPolicies(), loadSettings()]);
+      const [loadedPolicies, loadedSettings, catalog] = await Promise.all([listPolicies(), loadSettings(), listStarterPacks()]);
+      setStarterPacks(catalog.packs);
+      setStarterPack((current) => current || catalog.packs[0]?.name || "");
       setPolicies(loadedPolicies);
       setSettings(loadedSettings.settings);
       setSettingsExist(loadedSettings.exists);
@@ -128,7 +133,7 @@ export function EditorialChecksAdminPanel() {
       const key = draft.record.policyKey.trim();
       if (!POLICY_KEY.test(key)) throw new Error("The key must be lowercase letters, digits, dots, hyphens or underscores.");
       if (!draft.record.title.trim() || !draft.record.guidance.trim()) throw new Error("A policy needs a title and guidance.");
-      const policy = limatusPolicy(draft);
+      const policy = humanusPolicy(draft);
       const record: EditorialPolicyRecord = {
         ...draft.record,
         id: draft.isNew ? `${draft.record.scope}#${key}` : draft.record.id,
@@ -157,19 +162,38 @@ export function EditorialChecksAdminPanel() {
       <h4>Policies</h4>
       <div className="flex flex-wrap gap-2">
         <Button onClick={() => { setDraft(draftFrom(emptyPolicy(), true)); setTryResult(null); }} size="sm" type="button">New policy</Button>
+        <select aria-label="Starter pack" onChange={(event) => setStarterPack(event.target.value)} value={starterPack}>
+          {starterPacks.map((pack) => (
+            <option key={pack.name} value={pack.name}>
+              {pack.title} ({pack.importedCount} of {pack.policyCount} added)
+            </option>
+          ))}
+        </select>
         <Button
-          disabled={working !== null}
+          disabled={working !== null || !starterPack}
           onClick={() => run("import", async () => {
-            const outcome = await importStarterPack(STARTER_PACK);
+            const outcome = await importStarterPack(starterPack);
             await refresh();
-            return `Starter pack: ${outcome.created} policies added, ${outcome.skipped} already present.`;
+            const label = starterPacks.find((pack) => pack.name === starterPack)?.title ?? starterPack;
+            return `${label}: ${outcome.created} policies added, ${outcome.skipped} already present.`;
           })}
           size="sm"
           type="button"
           variant="outline"
         >
-          Add AI-writing tells starter pack
+          Add starter pack
         </Button>
+      </div>
+      {(() => {
+        const selected = starterPacks.find((pack) => pack.name === starterPack);
+        return selected ? (
+          <p className="text-sm text-muted-foreground">
+            {selected.title}{selected.version ? ` ${selected.version}` : ""}: {selected.policyCount} policies
+            {selected.isDefault ? " (added to every new site)" : ""}. {selected.guidance}
+          </p>
+        ) : null;
+      })()}
+      <div className="flex flex-wrap gap-2">
         <Button
           disabled={working !== null}
           onClick={() => run("recalibrate", async () => {
@@ -243,7 +267,7 @@ export function EditorialChecksAdminPanel() {
           <label>Examples that break it (one per line) <Textarea onChange={(event) => setDraft({ ...draft, violatesText: event.target.value })} rows={3} value={draft.violatesText} /></label>
           <label>Examples that follow it (one per line) <Textarea onChange={(event) => setDraft({ ...draft, compliesText: event.target.value })} rows={3} value={draft.compliesText} /></label>
           <label>
-            Detectors (JSON; see <code>limatus schema policy-pack-v1</code>)
+            Detectors (JSON; see <code>humanus schema policy-pack-v1</code>)
             <Textarea className="font-mono text-xs" onChange={(event) => setDraft({ ...draft, detectorsText: event.target.value })} rows={10} value={draft.detectorsText} />
           </label>
           <div className="flex flex-wrap gap-2">
@@ -284,7 +308,7 @@ export function EditorialChecksAdminPanel() {
             <Button
               disabled={working !== null || !tryText.trim()}
               onClick={() => run("try", async () => {
-                setTryResult(await tryPolicy(limatusPolicy(draft), tryText));
+                setTryResult(await tryPolicy(humanusPolicy(draft), tryText));
               })}
               size="sm"
               type="button"
@@ -320,6 +344,7 @@ export function EditorialChecksAdminPanel() {
           });
         }}
       >
+        <label><input checked={settings.enabled} data-editorial-enabled onChange={(event) => setSettings({ ...settings, enabled: event.target.checked })} type="checkbox" /> Run editorial checks for this publication (turning this off stops checks and rewrites; policies are kept)</label>
         <label><input checked={settings.lanes.rules} onChange={(event) => setSettings({ ...settings, lanes: { ...settings.lanes, rules: event.target.checked } })} type="checkbox" /> Rule checks</label>
         <label><input checked={settings.lanes.classifier} onChange={(event) => setSettings({ ...settings, lanes: { ...settings.lanes, classifier: event.target.checked } })} type="checkbox" /> Judgment checks (decision model)</label>
         <label><input checked={settings.checkWhileTyping} onChange={(event) => setSettings({ ...settings, checkWhileTyping: event.target.checked })} type="checkbox" /> Check while editors type (after a short pause)</label>