@anthusai/papyrus 2.0.2 → 3.0.0

package/amplify/plugins/editorial-checks/function/handler.py

@@ -0,0 +1,11 @@
+"""The editorial-checks plugin's function: routes its GraphQL fields to papyrus_content.editorial_checks."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from papyrus_content.editorial_checks import GraphQLEditorialStore, Services, handle
+
+
+def handler(event: dict[str, Any], _context: Any = None) -> dict[str, Any]:
+    return handle(event["info"]["fieldName"], event.get("arguments") or {}, Services(store=GraphQLEditorialStore()))

package/amplify/plugins/editorial-checks/function/requirements.txt

@@ -0,0 +1 @@
+limatus[jev]>=0.31,<0.32

package/amplify/plugins/editorial-checks/function/resource.js

@@ -0,0 +1,43 @@
+import { defineFunction } from "@aws-amplify/backend";
+import { Duration } from "aws-cdk-lib";
+import { Architecture, Function, Runtime } from "aws-cdk-lib/aws-lambda";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { pythonLambdaCode } from "../../../functions/shared/python-bundle.js";
+const functionDirectory = path.dirname(fileURLToPath(import.meta.url));
+/** AppSync gives a resolver 30 seconds; Limatus's classifier deadline (settings, default 20 s) keeps a check inside this. */
+export const EDITORIAL_CHECKS_TIMEOUT_SECONDS = 28;
+/** Limatus with the Jev classifier lane; papyrus_content.editorial_checks does the work. */
+export const editorialChecksRequirements = ["limatus[jev]>=0.31,<0.32"];
+function installRequirements(outputDir) {
+    execFileSync("python3", [
+        "-m", "pip", "install", "-r", path.join(functionDirectory, "requirements.txt"), "-t", outputDir, "--no-cache-dir",
+        "--platform", "manylinux2014_aarch64", "--implementation", "cp", "--python-version", "3.12",
+        "--only-binary=:all:", "--ignore-requires-python",
+    ], { stdio: "inherit" });
+}
+export const editorialChecks = defineFunction((scope) => new Function(scope, "papyrus-editorial-checks", {
+    runtime: Runtime.PYTHON_3_12,
+    architecture: Architecture.ARM_64,
+    handler: "handler.handler",
+    timeout: Duration.seconds(EDITORIAL_CHECKS_TIMEOUT_SECONDS),
+    memorySize: 1024,
+    code: pythonLambdaCode({
+        functionDir: "../plugins/editorial-checks/function",
+        modules: ["papyrus_content"],
+        requirements: editorialChecksRequirements,
+        noDeps: true,
+        checkoutExtras: installRequirements,
+    }, [
+        "bash",
+        "-c",
+        [
+            "set -euo pipefail",
+            "mkdir -p /asset-output/papyrus_content",
+            "cp amplify/plugins/editorial-checks/function/handler.py /asset-output/handler.py",
+            "cp -R src/papyrus_content/. /asset-output/papyrus_content/",
+            "python3 -m pip install -r amplify/plugins/editorial-checks/function/requirements.txt -t /asset-output --no-cache-dir",
+        ].join(" && "),
+    ]),
+}), { resourceGroupName: "data" });

package/amplify/plugins/editorial-checks/function/resource.ts

@@ -0,0 +1,60 @@
+import { defineFunction } from "@aws-amplify/backend";
+import { Duration } from "aws-cdk-lib";
+import { Architecture, Function, Runtime } from "aws-cdk-lib/aws-lambda";
+import type { Construct } from "constructs";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { pythonLambdaCode } from "../../../functions/shared/python-bundle";
+
+const functionDirectory = path.dirname(fileURLToPath(import.meta.url));
+
+/** AppSync gives a resolver 30 seconds; Limatus's classifier deadline (settings, default 20 s) keeps a check inside this. */
+export const EDITORIAL_CHECKS_TIMEOUT_SECONDS = 28;
+
+/** Limatus with the Jev classifier lane; papyrus_content.editorial_checks does the work. */
+export const editorialChecksRequirements = ["limatus[jev]>=0.31,<0.32"];
+
+function installRequirements(outputDir: string): void {
+  execFileSync(
+    "python3",
+    [
+      "-m", "pip", "install", "-r", path.join(functionDirectory, "requirements.txt"), "-t", outputDir, "--no-cache-dir",
+      "--platform", "manylinux2014_aarch64", "--implementation", "cp", "--python-version", "3.12",
+      "--only-binary=:all:", "--ignore-requires-python",
+    ],
+    { stdio: "inherit" },
+  );
+}
+
+export const editorialChecks = defineFunction(
+  (scope: Construct) =>
+    new Function(scope, "papyrus-editorial-checks", {
+      runtime: Runtime.PYTHON_3_12,
+      architecture: Architecture.ARM_64,
+      handler: "handler.handler",
+      timeout: Duration.seconds(EDITORIAL_CHECKS_TIMEOUT_SECONDS),
+      memorySize: 1024,
+      code: pythonLambdaCode(
+        {
+          functionDir: "../plugins/editorial-checks/function",
+          modules: ["papyrus_content"],
+          requirements: editorialChecksRequirements,
+          noDeps: true,
+          checkoutExtras: installRequirements,
+        },
+        [
+          "bash",
+          "-c",
+          [
+            "set -euo pipefail",
+            "mkdir -p /asset-output/papyrus_content",
+            "cp amplify/plugins/editorial-checks/function/handler.py /asset-output/handler.py",
+            "cp -R src/papyrus_content/. /asset-output/papyrus_content/",
+            "python3 -m pip install -r amplify/plugins/editorial-checks/function/requirements.txt -t /asset-output --no-cache-dir",
+          ].join(" && "),
+        ],
+      ),
+    }),
+  { resourceGroupName: "data" },
+);

package/amplify/plugins/editorial-checks/papyrus.plugin.js

@@ -0,0 +1,50 @@
+import { secret } from "@aws-amplify/backend";
+import { Stack } from "aws-cdk-lib";
+import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
+import { editorialChecks } from "./function/resource.js";
+import { editorialChecksSchemaDefinitions } from "./schema.js";
+export const EDITORIAL_CHECKS_QUERIES = ["checkEditorial", "suggestEditorialRewrite", "draftEditorialQuestions", "tryEditorialPolicy"];
+export const EDITORIAL_CHECKS_MUTATIONS = ["importEditorialStarterPack", "recalibrateEditorialPolicies"];
+/** The model operations the function performs with its own role. */
+export const EDITORIAL_CHECKS_FUNCTION_FIELDS = [
+    "Query/fields/listEditorialPolicies",
+    "Query/fields/getEditorialCheckSettings",
+    "Query/fields/listEditorialFeedbacks",
+    "Mutation/fields/createEditorialPolicy",
+    "Mutation/fields/updateEditorialPolicy",
+];
+export const editorialChecksManifest = {
+    name: "editorial-checks",
+    contract: 1,
+    models: ["EditorialPolicy", "EditorialCheckSettings", "EditorialFeedback"],
+    mutations: [...EDITORIAL_CHECKS_QUERIES, ...EDITORIAL_CHECKS_MUTATIONS],
+    guest: { mutations: [] },
+    newsroomPanels: [{ id: "editorial-checks", label: "Editorial checks" }],
+    staticAssets: [],
+};
+export function resolveEditorialChecksConfig(request) {
+    const raw = typeof request === "string" ? { name: request } : request;
+    const unknown = Object.keys(raw).filter((key) => key !== "name");
+    if (unknown.length > 0)
+        throw new Error(`Unknown editorial-checks plugin settings: ${unknown.join(", ")} (runtime settings are edited in the newsroom)`);
+    return {};
+}
+export const editorialChecksPlugin = {
+    manifest: editorialChecksManifest,
+    resolveConfig: resolveEditorialChecksConfig,
+    functions: () => ({ editorialChecks }),
+    schemaDefinitions: editorialChecksSchemaDefinitions,
+    publicSettings: () => ({ contract: editorialChecksManifest.contract }),
+    wire(backend, _config, context) {
+        const lambda = backend.editorialChecks.resources.lambda;
+        const stack = Stack.of(lambda);
+        lambda.addEnvironment("PAPYRUS_GRAPHQL_ENDPOINT", context.graphqlEndpoint);
+        backend.editorialChecks.addEnvironment("TYPESAFE_API_KEY", secret("TYPESAFE_API_KEY"));
+        backend.editorialChecks.addEnvironment("OPENAI_API_KEY", secret("OPENAI_API_KEY"));
+        lambda.addToRolePolicy(new PolicyStatement({
+            effect: Effect.ALLOW,
+            actions: ["appsync:GraphQL"],
+            resources: EDITORIAL_CHECKS_FUNCTION_FIELDS.map((field) => `arn:aws:appsync:${stack.region}:${stack.account}:apis/${context.graphqlApiId}/types/${field}`),
+        }));
+    },
+};

package/amplify/plugins/editorial-checks/papyrus.plugin.ts

@@ -0,0 +1,63 @@
+import { secret } from "@aws-amplify/backend";
+import { Stack } from "aws-cdk-lib";
+import { Effect, PolicyStatement } from "aws-cdk-lib/aws-iam";
+import type { Function as LambdaFunction } from "aws-cdk-lib/aws-lambda";
+import type { PapyrusPlugin, PluginManifest, PluginRequest, PluginWiringContext } from "../types";
+import { editorialChecks } from "./function/resource";
+import { editorialChecksSchemaDefinitions } from "./schema";
+
+/** Runtime settings (lanes, models, deadline) live in EditorialCheckSettings, edited in the newsroom; enabling the plugin takes no options. */
+export type EditorialChecksPluginConfig = Record<string, never>;
+
+export const EDITORIAL_CHECKS_QUERIES = ["checkEditorial", "suggestEditorialRewrite", "draftEditorialQuestions", "tryEditorialPolicy"];
+export const EDITORIAL_CHECKS_MUTATIONS = ["importEditorialStarterPack", "recalibrateEditorialPolicies"];
+
+/** The model operations the function performs with its own role. */
+export const EDITORIAL_CHECKS_FUNCTION_FIELDS = [
+  "Query/fields/listEditorialPolicies",
+  "Query/fields/getEditorialCheckSettings",
+  "Query/fields/listEditorialFeedbacks",
+  "Mutation/fields/createEditorialPolicy",
+  "Mutation/fields/updateEditorialPolicy",
+];
+
+export const editorialChecksManifest: PluginManifest = {
+  name: "editorial-checks",
+  contract: 1,
+  models: ["EditorialPolicy", "EditorialCheckSettings", "EditorialFeedback"],
+  mutations: [...EDITORIAL_CHECKS_QUERIES, ...EDITORIAL_CHECKS_MUTATIONS],
+  guest: { mutations: [] },
+  newsroomPanels: [{ id: "editorial-checks", label: "Editorial checks" }],
+  staticAssets: [],
+};
+
+export function resolveEditorialChecksConfig(request: PluginRequest): EditorialChecksPluginConfig {
+  const raw = typeof request === "string" ? { name: request } : request;
+  const unknown = Object.keys(raw).filter((key) => key !== "name");
+  if (unknown.length > 0) throw new Error(`Unknown editorial-checks plugin settings: ${unknown.join(", ")} (runtime settings are edited in the newsroom)`);
+  return {};
+}
+
+export const editorialChecksPlugin: PapyrusPlugin<EditorialChecksPluginConfig, { editorialChecks: typeof editorialChecks }> = {
+  manifest: editorialChecksManifest,
+  resolveConfig: resolveEditorialChecksConfig,
+  functions: () => ({ editorialChecks }),
+  schemaDefinitions: editorialChecksSchemaDefinitions,
+  publicSettings: () => ({ contract: editorialChecksManifest.contract }),
+  wire(backend, _config, context: PluginWiringContext) {
+    const lambda = backend.editorialChecks.resources.lambda as LambdaFunction;
+    const stack = Stack.of(lambda);
+    lambda.addEnvironment("PAPYRUS_GRAPHQL_ENDPOINT", context.graphqlEndpoint);
+    backend.editorialChecks.addEnvironment("TYPESAFE_API_KEY", secret("TYPESAFE_API_KEY"));
+    backend.editorialChecks.addEnvironment("OPENAI_API_KEY", secret("OPENAI_API_KEY"));
+    lambda.addToRolePolicy(
+      new PolicyStatement({
+        effect: Effect.ALLOW,
+        actions: ["appsync:GraphQL"],
+        resources: EDITORIAL_CHECKS_FUNCTION_FIELDS.map(
+          (field) => `arn:aws:appsync:${stack.region}:${stack.account}:apis/${context.graphqlApiId}/types/${field}`,
+        ),
+      }),
+    );
+  },
+};

package/amplify/plugins/editorial-checks/schema.js

@@ -0,0 +1,94 @@
+import { a } from "@aws-amplify/backend";
+import { editorialChecks } from "./function/resource.js";
+const editors = ["editor", "admin"];
+/**
+ * Policies, settings and editors' decisions live in Papyrus; Limatus checks
+ * content against them. Editors read policies and record decisions; admins
+ * manage policies and settings. Only the function (IAM) calls Limatus.
+ */
+export function editorialChecksSchemaDefinitions() {
+    return {
+        EditorialPolicy: a
+            .model({
+            id: a.id().required(),
+            policyKey: a.string().required(),
+            scope: a.string().required(),
+            version: a.integer().required(),
+            title: a.string().required(),
+            guidance: a.string().required(),
+            severity: a.string().required(),
+            enabled: a.boolean().required(),
+            detectors: a.json().required(),
+            examples: a.json(),
+            rewriteGuidance: a.string(),
+            source: a.string().required(),
+        })
+            .disableOperations(["subscriptions"])
+            .authorization((allow) => [allow.group("editor").to(["read"]), allow.group("admin")]),
+        EditorialCheckSettings: a
+            .model({
+            id: a.id().required(),
+            settings: a.json().required(),
+        })
+            .disableOperations(["subscriptions"])
+            .authorization((allow) => [allow.group("editor").to(["read"]), allow.group("admin")]),
+        EditorialFeedback: a
+            .model({
+            id: a.id().required(),
+            itemId: a.string().required(),
+            findingId: a.string().required(),
+            policyId: a.string().required(),
+            detectorId: a.string().required(),
+            lane: a.string().required(),
+            probability: a.float(),
+            decision: a.string().required(),
+            reason: a.string(),
+            text: a.string(),
+        })
+            .disableOperations(["subscriptions"])
+            .secondaryIndexes((index) => [index("itemId").queryField("listEditorialFeedbackByItem")])
+            .authorization((allow) => [allow.group("editor").to(["create", "read"]), allow.group("admin")]),
+        checkEditorial: a
+            .query()
+            .arguments({ body: a.string().required(), format: a.string(), section: a.string() })
+            .returns(a.json())
+            .authorization((allow) => [allow.groups(editors)])
+            .handler(a.handler.function(editorialChecks)),
+        suggestEditorialRewrite: a
+            .query()
+            .arguments({
+            body: a.string().required(),
+            format: a.string(),
+            section: a.string(),
+            finding: a.json(),
+            selection: a.json(),
+            note: a.string(),
+        })
+            .returns(a.json())
+            .authorization((allow) => [allow.groups(editors)])
+            .handler(a.handler.function(editorialChecks)),
+        draftEditorialQuestions: a
+            .query()
+            .arguments({ title: a.string().required(), guidance: a.string().required(), examples: a.json() })
+            .returns(a.json())
+            .authorization((allow) => [allow.group("admin")])
+            .handler(a.handler.function(editorialChecks)),
+        tryEditorialPolicy: a
+            .query()
+            .arguments({ policy: a.json().required(), text: a.string().required(), format: a.string() })
+            .returns(a.json())
+            .authorization((allow) => [allow.group("admin")])
+            .handler(a.handler.function(editorialChecks)),
+        importEditorialStarterPack: a
+            .mutation()
+            .arguments({ name: a.string().required() })
+            .returns(a.json())
+            .authorization((allow) => [allow.group("admin")])
+            .handler(a.handler.function(editorialChecks)),
+        recalibrateEditorialPolicies: a
+            .mutation()
+            .returns(a.json())
+            .authorization((allow) => [allow.group("admin")])
+            .handler(a.handler.function(editorialChecks)),
+    };
+}

package/amplify/plugins/editorial-checks/schema.ts

@@ -0,0 +1,96 @@
+import { a } from "@aws-amplify/backend";
+import { editorialChecks } from "./function/resource";
+
+const editors = ["editor", "admin"];
+
+/**
+ * Policies, settings and editors' decisions live in Papyrus; Limatus checks
+ * content against them. Editors read policies and record decisions; admins
+ * manage policies and settings. Only the function (IAM) calls Limatus.
+ */
+export function editorialChecksSchemaDefinitions() {
+  return {
+    EditorialPolicy: a
+      .model({
+        id: a.id().required(),
+        policyKey: a.string().required(),
+        scope: a.string().required(),
+        version: a.integer().required(),
+        title: a.string().required(),
+        guidance: a.string().required(),
+        severity: a.string().required(),
+        enabled: a.boolean().required(),
+        detectors: a.json().required(),
+        examples: a.json(),
+        rewriteGuidance: a.string(),
+        source: a.string().required(),
+      })
+      .disableOperations(["subscriptions"])
+      .authorization((allow) => [allow.group("editor").to(["read"]), allow.group("admin")]),
+    EditorialCheckSettings: a
+      .model({
+        id: a.id().required(),
+        settings: a.json().required(),
+      })
+      .disableOperations(["subscriptions"])
+      .authorization((allow) => [allow.group("editor").to(["read"]), allow.group("admin")]),
+    EditorialFeedback: a
+      .model({
+        id: a.id().required(),
+        itemId: a.string().required(),
+        findingId: a.string().required(),
+        policyId: a.string().required(),
+        detectorId: a.string().required(),
+        lane: a.string().required(),
+        probability: a.float(),
+        decision: a.string().required(),
+        reason: a.string(),
+        text: a.string(),
+      })
+      .disableOperations(["subscriptions"])
+      .secondaryIndexes((index) => [index("itemId").queryField("listEditorialFeedbackByItem")])
+      .authorization((allow) => [allow.group("editor").to(["create", "read"]), allow.group("admin")]),
+    checkEditorial: a
+      .query()
+      .arguments({ body: a.string().required(), format: a.string(), section: a.string() })
+      .returns(a.json())
+      .authorization((allow) => [allow.groups(editors)])
+      .handler(a.handler.function(editorialChecks)),
+    suggestEditorialRewrite: a
+      .query()
+      .arguments({
+        body: a.string().required(),
+        format: a.string(),
+        section: a.string(),
+        finding: a.json(),
+        selection: a.json(),
+        note: a.string(),
+      })
+      .returns(a.json())
+      .authorization((allow) => [allow.groups(editors)])
+      .handler(a.handler.function(editorialChecks)),
+    draftEditorialQuestions: a
+      .query()
+      .arguments({ title: a.string().required(), guidance: a.string().required(), examples: a.json() })
+      .returns(a.json())
+      .authorization((allow) => [allow.group("admin")])
+      .handler(a.handler.function(editorialChecks)),
+    tryEditorialPolicy: a
+      .query()
+      .arguments({ policy: a.json().required(), text: a.string().required(), format: a.string() })
+      .returns(a.json())
+      .authorization((allow) => [allow.group("admin")])
+      .handler(a.handler.function(editorialChecks)),
+    importEditorialStarterPack: a
+      .mutation()
+      .arguments({ name: a.string().required() })
+      .returns(a.json())
+      .authorization((allow) => [allow.group("admin")])
+      .handler(a.handler.function(editorialChecks)),
+    recalibrateEditorialPolicies: a
+      .mutation()
+      .returns(a.json())
+      .authorization((allow) => [allow.group("admin")])
+      .handler(a.handler.function(editorialChecks)),
+  };
+}

package/amplify/plugins/registry.js

@@ -1,6 +1,8 @@
+import { editorialChecksPlugin } from "./editorial-checks/papyrus.plugin.js";
 import { signupPlugin } from "./signup/papyrus.plugin.js";
 /** Plugins are packaged with Papyrus and pinned by its version: there is no registry to fetch from. */
 export const KNOWN_PLUGINS = {
+    "editorial-checks": editorialChecksPlugin,
     signup: signupPlugin,
 };
 export function resolvePlugins(requests) {

package/amplify/plugins/registry.ts

@@ -1,8 +1,10 @@
 import type { PapyrusPlugin, PluginRequest } from "./types";
+import { editorialChecksPlugin } from "./editorial-checks/papyrus.plugin";
 import { signupPlugin } from "./signup/papyrus.plugin";
 
 /** Plugins are packaged with Papyrus and pinned by its version: there is no registry to fetch from. */
 export const KNOWN_PLUGINS: Record<string, PapyrusPlugin<any, any>> = {
+  "editorial-checks": editorialChecksPlugin,
   signup: signupPlugin,
 };