@manta-eu/react 0.12.0 → 0.13.0

package/src/routes/memories/schemas/SchemaTemplatesDialog.tsx

@@ -0,0 +1,81 @@
+import type { GQLMemorySchemaTemplatesQuery } from "@manta-eu/client";
+import { humanCount } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+import { Banner } from "#components/banner/index";
+import { Button } from "#components/button/index";
+import { Loader } from "#components/loader/index";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "#components/modal/index";
+
+export type MemorySchemaTemplate = GQLMemorySchemaTemplatesQuery["memorySchemaTemplates"]["templates"][number];
+
+export type SchemaTemplatesDialogProps = {
+  open: boolean;
+  templates: readonly MemorySchemaTemplate[];
+  isLoading: boolean;
+  errorMessage?: string | null;
+  addingIri: string | null;
+  onAdd: (templateIri: string) => void;
+  onClose: () => void;
+};
+
+export function SchemaTemplatesDialog(props: SchemaTemplatesDialogProps) {
+  const { open, templates, isLoading, errorMessage, addingIri, onAdd, onClose } = props;
+  const available = templates.filter((template) => !template.live);
+
+  return (
+    <Dialog open={open} onOpenChange={(next) => !next && onClose()}>
+      <DialogContent className="flex flex-col overflow-hidden">
+        <DialogHeader>
+          <DialogTitle text="Restore a default schema" />
+          <DialogDescription>
+            Manta ships these schemas. Restoring one gives this datastore its own copy to edit again.
+          </DialogDescription>
+        </DialogHeader>
+        <div className="-mx-8 flex min-h-0 flex-1 flex-col gap-2 overflow-y-auto px-8 py-1">
+          {errorMessage && <Banner label={errorMessage} className="shrink-0" />}
+          {isLoading ? (
+            <div className="flex justify-center py-6">
+              <Loader className="size-6" />
+            </div>
+          ) : isPresent(available) ? (
+            available.map(({ schema }) => (
+              <div key={schema.iri} className="flex items-center gap-3 rounded-lg border border-muted-border p-3">
+                <div className="flex min-w-0 flex-1 flex-col gap-0.5">
+                  <span className="truncate typography-small-medium">{schema.label}</span>
+                  <span className="typography-tiny text-muted-foreground">
+                    {schema.description ?? humanCount(schema.properties.length, "property")}
+                  </span>
+                </div>
+                <Button
+                  size="sm"
+                  variant="secondary"
+                  disabled={addingIri !== null}
+                  aria-label={`Restore ${schema.label}`}
+                  onClick={() => onAdd(schema.iri)}
+                >
+                  {addingIri === schema.iri ? "Restoring…" : "Restore"}
+                </Button>
+              </div>
+            ))
+          ) : (
+            <p className="py-4 typography-small text-muted-foreground">
+              Every default schema is already in this datastore.
+            </p>
+          )}
+        </div>
+        <DialogFooter>
+          <Button variant="tertiary" onClick={onClose}>
+            Close
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

package/src/routes/memories/schemas/ValueTypeSelect.tsx

@@ -0,0 +1,37 @@
+import { GQLMemorySchemaValueType } from "@manta-eu/client";
+import { valueTypeLabels } from "./schema-form";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "#components/select/index";
+
+const valueTypes = Object.values(GQLMemorySchemaValueType);
+
+export type ValueTypeSelectProps = {
+  id: string;
+  label: string;
+  value: GQLMemorySchemaValueType;
+  disabled?: boolean;
+  error?: string;
+  className?: string;
+  onChange: (valueType: GQLMemorySchemaValueType) => void;
+};
+
+export function ValueTypeSelect(props: ValueTypeSelectProps) {
+  const { id, label, value, disabled, error, className, onChange } = props;
+  return (
+    <Select
+      value={value}
+      disabled={disabled}
+      onValueChange={(next) => onChange(valueTypes.find((type) => type === next) ?? value)}
+    >
+      <SelectTrigger label={label} id={id} hiddenLabel error={error} className={className}>
+        <SelectValue />
+      </SelectTrigger>
+      <SelectContent>
+        {valueTypes.map((type) => (
+          <SelectItem key={type} value={type}>
+            {valueTypeLabels[type]}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}

package/src/routes/memories/schemas/schema-form.ts

@@ -0,0 +1,360 @@
+import {
+  GQLMemoryKind,
+  GQLMemorySchemaValueType,
+  GQLMemoryScope,
+  GQLMemoryVolatility,
+  type GQLMemorySchemaFieldsFragment,
+  type GQLMemorySchemaDefinitionInput,
+  type GQLMemorySchemaPropertyDefinitionInput,
+  type GQLMemorySchemaValidationError,
+} from "@manta-eu/client";
+import { memorySchemaLimits } from "@manta-eu/client/shared/memory-schema-limits";
+import {
+  checkMemorySchemaProperty,
+  deriveMemoryPropertyKey,
+  memoryPropertyKeyProblem,
+} from "@manta-eu/client/shared/memory-schema-property";
+import {
+  memorySchemaValueTypes,
+  parseMemoryValue,
+  type CompileMemoryValuePattern,
+} from "@manta-eu/client/shared/memory-schema-values";
+import { humanCount } from "@manta-eu/lib/humanize";
+import { isPresent } from "@manta-eu/lib/present";
+
+let compilePattern: CompileMemoryValuePattern | null = null;
+
+// RE2 is large, so it loads with the schema editor rather than with the app. Until it has, only the server checks a
+// pattern, and it does so again on every save anyway.
+export async function loadPatternCheck(): Promise<void> {
+  compilePattern ??= (await import("@manta-eu/client/shared/memory-schema-pattern")).compileMemoryValuePattern;
+}
+
+export const memorySchemaPropertyLimit = memorySchemaLimits.properties;
+export const memorySchemaOptionLimit = memorySchemaLimits.options;
+
+export type SchemaOptionForm = { id: string; value: string; label: string; description: string };
+
+export type SchemaPropertyForm = {
+  id: string;
+  path: string | null;
+  key: string;
+  label: string;
+  description: string;
+  valueType: GQLMemorySchemaValueType;
+  entityClass: string;
+  required: boolean;
+  multiValued: boolean;
+  keyProperty: boolean;
+  computed: boolean;
+  options: SchemaOptionForm[];
+  minValue: string;
+  maxValue: string;
+  maxLength: string;
+  pattern: string;
+  defaultValue: string;
+  unit: string;
+};
+
+export type SchemaForm = {
+  key: string;
+  label: string;
+  description: string;
+  defaultMemoryKind: GQLMemoryKind | null;
+  defaultVolatility: GQLMemoryVolatility | null;
+  defaultImportance: number | null;
+  defaultScope: GQLMemoryScope | null;
+  extractionEnabled: boolean;
+  extractionGuidance: string;
+  properties: SchemaPropertyForm[];
+};
+
+export const kindLabels: Record<GQLMemoryKind, string> = {
+  [GQLMemoryKind.Fact]: "Fact",
+  [GQLMemoryKind.Preference]: "Preference",
+  [GQLMemoryKind.Objective]: "Objective",
+  [GQLMemoryKind.Context]: "Context",
+};
+
+export const volatilityLabels: Record<GQLMemoryVolatility, string> = {
+  [GQLMemoryVolatility.Stable]: "Stable",
+  [GQLMemoryVolatility.Slow]: "Changes slowly",
+  [GQLMemoryVolatility.Volatile]: "Changes often",
+};
+
+export const scopeLabels: Record<GQLMemoryScope, string> = {
+  [GQLMemoryScope.User]: "Personal",
+  [GQLMemoryScope.Team]: "Team",
+  [GQLMemoryScope.Company]: "Company",
+};
+
+export const valueTypeLabels: Record<GQLMemorySchemaValueType, string> = {
+  [GQLMemorySchemaValueType.Text]: "Text",
+  [GQLMemorySchemaValueType.LongText]: "Long text",
+  [GQLMemorySchemaValueType.Integer]: "Whole number",
+  [GQLMemorySchemaValueType.Decimal]: "Decimal number",
+  [GQLMemorySchemaValueType.Boolean]: "Yes / no",
+  [GQLMemorySchemaValueType.Date]: "Date",
+  [GQLMemorySchemaValueType.DateTime]: "Date and time",
+  [GQLMemorySchemaValueType.Url]: "Web address",
+  [GQLMemorySchemaValueType.Entity]: "Linked record",
+};
+
+const boundTypes: readonly GQLMemorySchemaValueType[] = [
+  GQLMemorySchemaValueType.Integer,
+  GQLMemorySchemaValueType.Decimal,
+  GQLMemorySchemaValueType.Date,
+  GQLMemorySchemaValueType.DateTime,
+];
+const textTypes: readonly GQLMemorySchemaValueType[] = [
+  GQLMemorySchemaValueType.Text,
+  GQLMemorySchemaValueType.LongText,
+];
+const numberTypes: readonly GQLMemorySchemaValueType[] = [
+  GQLMemorySchemaValueType.Integer,
+  GQLMemorySchemaValueType.Decimal,
+];
+
+// Mirrors which settings the server accepts per type, so switching type never sends one it would refuse.
+export function propertySettings(valueType: GQLMemorySchemaValueType) {
+  return {
+    options: valueType === GQLMemorySchemaValueType.Text,
+    bounds: boundTypes.includes(valueType),
+    maxLength: [...textTypes, GQLMemorySchemaValueType.Url].includes(valueType),
+    pattern: textTypes.includes(valueType),
+    unit: numberTypes.includes(valueType),
+    entityClass: valueType === GQLMemorySchemaValueType.Entity,
+    keyProperty: valueType !== GQLMemorySchemaValueType.LongText,
+  };
+}
+
+// Only what the save keeps for this type, so a setting left behind by a type switch is not shown as in effect.
+export function propertyTags(property: SchemaPropertyForm): string[] {
+  const settings = propertySettings(property.valueType);
+  return [
+    property.computed ? "Computed" : property.required ? "Required" : "",
+    property.multiValued ? "List" : "",
+    settings.keyProperty && property.keyProperty && !property.multiValued && !property.computed ? "Identifies" : "",
+    settings.unit ? property.unit.trim() : "",
+    settings.options && isPresent(property.options) ? humanCount(property.options.length, "allowed value") : "",
+  ].filter(isPresent);
+}
+
+export function withValueType(property: SchemaPropertyForm, valueType: GQLMemorySchemaValueType): SchemaPropertyForm {
+  const type = memorySchemaValueTypes.find((candidate) => candidate === valueType);
+  const kept = (raw: string) => (type !== undefined && parseMemoryValue(type, raw) !== null ? raw : "");
+  return {
+    ...property,
+    valueType,
+    minValue: kept(property.minValue),
+    maxValue: kept(property.maxValue),
+    defaultValue: kept(property.defaultValue),
+  };
+}
+
+export function newFormId(): string {
+  return crypto.randomUUID();
+}
+
+export function emptyPropertyForm(): SchemaPropertyForm {
+  return {
+    id: newFormId(),
+    path: null,
+    key: "",
+    label: "",
+    description: "",
+    valueType: GQLMemorySchemaValueType.Text,
+    entityClass: "",
+    required: false,
+    multiValued: false,
+    keyProperty: false,
+    computed: false,
+    options: [],
+    minValue: "",
+    maxValue: "",
+    maxLength: "",
+    pattern: "",
+    defaultValue: "",
+    unit: "",
+  };
+}
+
+export function emptySchemaForm(): SchemaForm {
+  return {
+    key: "",
+    label: "",
+    description: "",
+    defaultMemoryKind: null,
+    defaultVolatility: null,
+    defaultImportance: null,
+    defaultScope: null,
+    extractionEnabled: true,
+    extractionGuidance: "",
+    properties: [],
+  };
+}
+
+export function schemaFormFromSchema(schema: GQLMemorySchemaFieldsFragment): SchemaForm {
+  return {
+    key: "",
+    label: schema.label,
+    description: schema.description ?? "",
+    defaultMemoryKind: schema.defaultMemoryKind ?? null,
+    defaultVolatility: schema.defaultVolatility ?? null,
+    defaultImportance: schema.defaultImportance ?? null,
+    defaultScope: schema.defaultScope ?? null,
+    extractionEnabled: schema.extractionEnabled,
+    extractionGuidance: schema.extractionGuidance ?? "",
+    properties: [...schema.properties]
+      .sort((a, b) => a.order - b.order)
+      .map((property) => ({
+        id: newFormId(),
+        path: property.path,
+        key: "",
+        label: property.label,
+        description: property.description ?? "",
+        valueType: property.valueType,
+        entityClass: property.entityClass ?? "",
+        required: property.required,
+        multiValued: property.multiValued,
+        keyProperty: property.keyProperty,
+        computed: property.computed,
+        options: property.options.map((option) => ({
+          id: newFormId(),
+          value: option.value,
+          label: option.label ?? "",
+          description: option.description ?? "",
+        })),
+        minValue: property.minValue ?? "",
+        maxValue: property.maxValue ?? "",
+        maxLength: property.maxLength != null ? String(property.maxLength) : "",
+        pattern: property.pattern ?? "",
+        defaultValue: property.defaultValue ?? "",
+        unit: property.unit ?? "",
+      })),
+  };
+}
+
+function textOrNull(value: string): string | null {
+  const trimmed = value.trim();
+  return isPresent(trimmed) ? trimmed : null;
+}
+
+function maxLengthOrNull(value: string): number | null {
+  const trimmed = value.trim();
+  return isPresent(trimmed) && /^\d+$/.test(trimmed) ? Number(trimmed) : null;
+}
+
+function propertyInput(property: SchemaPropertyForm): GQLMemorySchemaPropertyDefinitionInput {
+  const settings = propertySettings(property.valueType);
+  const key = textOrNull(property.key);
+  return {
+    ...(property.path !== null ? { path: property.path } : key !== null ? { key } : {}),
+    label: property.label.trim(),
+    description: textOrNull(property.description),
+    valueType: property.valueType,
+    entityClass: settings.entityClass ? textOrNull(property.entityClass) : null,
+    required: property.required && !property.computed,
+    multiValued: property.multiValued,
+    keyProperty: settings.keyProperty && property.keyProperty && !property.multiValued && !property.computed,
+    computed: property.computed,
+    options: settings.options
+      ? property.options.map((option) => ({
+          value: option.value.trim(),
+          label: textOrNull(option.label),
+          description: textOrNull(option.description),
+        }))
+      : [],
+    minValue: settings.bounds ? textOrNull(property.minValue) : null,
+    maxValue: settings.bounds ? textOrNull(property.maxValue) : null,
+    maxLength: settings.maxLength ? maxLengthOrNull(property.maxLength) : null,
+    pattern: settings.pattern ? textOrNull(property.pattern) : null,
+    defaultValue: property.computed ? null : textOrNull(property.defaultValue),
+    unit: settings.unit ? textOrNull(property.unit) : null,
+  };
+}
+
+export function schemaDefinitionInput(form: SchemaForm, options: { isNew: boolean }): GQLMemorySchemaDefinitionInput {
+  const key = textOrNull(form.key);
+  return {
+    ...(options.isNew && key !== null ? { key } : {}),
+    label: form.label.trim(),
+    description: textOrNull(form.description),
+    defaultMemoryKind: form.defaultMemoryKind,
+    defaultVolatility: form.defaultVolatility,
+    defaultImportance: form.defaultImportance,
+    defaultScope: form.defaultScope,
+    extractionEnabled: form.extractionEnabled,
+    extractionGuidance: form.extractionEnabled ? textOrNull(form.extractionGuidance) : null,
+    properties: form.properties.map(propertyInput),
+  };
+}
+
+export type SchemaFormErrors = ReadonlyMap<string, string>;
+
+export function propertyFormErrors(
+  property: SchemaPropertyForm,
+  prefix: string,
+  siblings: readonly SchemaPropertyForm[] = [],
+): Map<string, string> {
+  const errors = new Map<string, string>();
+  function add(field: string, message: string) {
+    if (!errors.has(field)) errors.set(field, message);
+  }
+
+  const maxLength = property.maxLength.trim();
+  if (propertySettings(property.valueType).maxLength && isPresent(maxLength) && !/^\d+$/.test(maxLength)) {
+    add(`${prefix}.maxLength`, "The maximum length must be a whole number");
+  }
+  for (const error of checkMemorySchemaProperty(propertyInput(property), prefix, compilePattern).errors)
+    add(error.field, error.message);
+
+  const label = property.label.trim();
+  const key = textOrNull(property.key);
+  if (property.path === null && (key !== null || isPresent(label))) {
+    const problem = memoryPropertyKeyProblem(key ?? deriveMemoryPropertyKey(label));
+    if (problem !== null) add(`${prefix}.key`, problem);
+  }
+  if (isPresent(label)) {
+    const clash = siblings.find(
+      (other) => other.id !== property.id && other.label.trim().toLowerCase() === label.toLowerCase(),
+    );
+    if (clash !== undefined) add(`${prefix}.label`, "Another property already uses this label");
+  }
+  return errors;
+}
+
+export function localSchemaFormErrors(form: SchemaForm): SchemaFormErrors {
+  const errors = new Map<string, string>();
+  form.properties.forEach((property, index) => {
+    for (const [field, message] of propertyFormErrors(property, propertyErrorPrefix(index), form.properties)) {
+      errors.set(field, message);
+    }
+  });
+  return errors;
+}
+
+// The server names a field by its place in the submitted definition, e.g. `properties.2.options.0.value`.
+export function schemaFormErrors(errors: readonly GQLMemorySchemaValidationError[]): SchemaFormErrors {
+  const byField = new Map<string, string>();
+  for (const { field, message } of errors) {
+    if (!byField.has(field)) byField.set(field, message);
+  }
+  return byField;
+}
+
+export function propertyErrorPrefix(index: number): string {
+  return `properties.${index}`;
+}
+
+export function hasErrorsUnder(errors: SchemaFormErrors, prefix: string): boolean {
+  return [...errors.keys()].some((field) => field === prefix || field.startsWith(`${prefix}.`));
+}
+
+export function moveItem<T>(items: readonly T[], from: number, to: number): T[] {
+  if (to < 0 || to >= items.length || from === to) return [...items];
+  const next = [...items];
+  const [moved] = next.splice(from, 1);
+  if (moved !== undefined) next.splice(to, 0, moved);
+  return next;
+}

package/src/routes/memories/schemas/schema-impact.ts

@@ -0,0 +1,66 @@
+import type {
+  GQLMemorySchemaFieldsFragment,
+  GQLMemorySchemaMutationResultFragment,
+  GQLMemorySchemaOptionRemapInput,
+} from "@manta-eu/client";
+import { isPresent } from "@manta-eu/lib/present";
+import { getRuleDisplayName } from "#routes/rules/components/rules.utils";
+
+export type MemorySchemaImpact = NonNullable<GQLMemorySchemaMutationResultFragment["impact"]>;
+
+export type RemovedOptionInUse = MemorySchemaImpact["removedOptions"][number];
+
+export type OptionRemapChoices = Record<string, string>;
+
+export const clearValueChoice = "__clear__";
+
+// Longest IRI first, so a rule IRI that is a prefix of another never rewrites part of the longer one.
+export function readableBlockers(impact: Pick<MemorySchemaImpact, "blockers" | "ruleReferences">): string[] {
+  const ruleIris = [...new Set(impact.ruleReferences.map((reference) => reference.ruleIri))].sort(
+    (a, b) => b.length - a.length,
+  );
+  return impact.blockers.map((blocker) =>
+    ruleIris.reduce((text, ruleIri) => text.split(ruleIri).join(getRuleDisplayName(ruleIri)), blocker),
+  );
+}
+
+export function remapChoiceKey(option: Pick<RemovedOptionInUse, "path" | "value">): string {
+  return `${option.path}\u0000${option.value}`;
+}
+
+// A change that moves no stored value and names no rule can be saved without a review step.
+export function impactNeedsReview(impact: MemorySchemaImpact): boolean {
+  return (
+    isPresent(impact.blockers) ||
+    isPresent(impact.ruleReferences) ||
+    impact.removedProperties.some((property) => property.memoryCount > 0) ||
+    impact.typeChanges.some((change) => change.valueCount > 0) ||
+    impact.removedOptions.some((option) => option.memoryCount > 0) ||
+    isPresent(impact.limitViolations) ||
+    isPresent(impact.multiValueConflicts) ||
+    impact.clearedValues.some((property) => property.memoryCount > 0)
+  );
+}
+
+export function removedOptionsInUse(impact: MemorySchemaImpact): RemovedOptionInUse[] {
+  return impact.removedOptions.filter((option) => option.memoryCount > 0);
+}
+
+export function remapTargets(proposed: GQLMemorySchemaFieldsFragment | null | undefined, path: string): string[] {
+  return proposed?.properties.find((property) => property.path === path)?.allowedValues ?? [];
+}
+
+export function optionRemapsInput(
+  impact: MemorySchemaImpact,
+  choices: OptionRemapChoices,
+): GQLMemorySchemaOptionRemapInput[] {
+  return removedOptionsInUse(impact).flatMap((option) => {
+    const choice = choices[remapChoiceKey(option)];
+    if (choice === undefined) return [];
+    return [{ path: option.path, from: option.value, to: choice === clearValueChoice ? null : choice }];
+  });
+}
+
+export function hasInvalidValues(impact: MemorySchemaImpact): boolean {
+  return impact.typeChanges.some((change) => change.unconvertibleCount > 0) || isPresent(impact.limitViolations);
+}

package/src/routes/memories/schemas/schema-route.ts

@@ -0,0 +1,30 @@
+export const memorySchemasPath = "/memories?tab=schemas";
+export const newMemorySchemaPath = "/memories/schemas/new";
+
+// The whole IRI names the page: IRIs are opaque, so no part of one is a name to route by.
+export function memorySchemaPath(iri: string): string {
+  return `/memories/schemas/${encodeURIComponent(iri)}`;
+}
+
+export function memorySchemaEditPath(iri: string): string {
+  return `${memorySchemaPath(iri)}/edit`;
+}
+
+export function findMemorySchemaByRouteName<T extends { iri: string }>(
+  schemas: readonly T[],
+  routeName: string,
+): T | null {
+  return schemas.find((schema) => schema.iri === routeName) ?? null;
+}
+
+export type MemorySchemaView =
+  | { kind: "new" }
+  | { kind: "detail"; routeName: string }
+  | { kind: "edit"; routeName: string };
+
+export function memorySchemaView(pathname: string, schemaName: string | undefined): MemorySchemaView | null {
+  const path = pathname.replace(/\/+$/, "");
+  if (path.endsWith(newMemorySchemaPath)) return { kind: "new" };
+  if (schemaName === undefined || !path.includes("/memories/schemas/")) return null;
+  return path.endsWith("/edit") ? { kind: "edit", routeName: schemaName } : { kind: "detail", routeName: schemaName };
+}

package/src/routes/memories/schemas/schema-rule-context.ts

@@ -0,0 +1,103 @@
+import {
+  GQLMemorySchemaValueType,
+  type GQLMemory,
+  type GQLMemorySchemaFieldsFragment,
+  type GQLMemorySchemaPropertyFieldsFragment,
+} from "@manta-eu/client";
+import { isPresent } from "@manta-eu/lib/present";
+import { valueTypeLabels } from "./schema-form";
+import type { CreateRuleChatSubject } from "#routes/rules/components/CreateRuleChatModal";
+
+export type RuleDraftRequest = { key: string; subject: CreateRuleChatSubject; suggestions: string[] };
+
+type Schema = GQLMemorySchemaFieldsFragment;
+
+type Property = GQLMemorySchemaPropertyFieldsFragment;
+
+export function memorySchemaRuleContext(schema: Schema): string {
+  const fields = [...schema.properties]
+    .sort((a, b) => a.order - b.order)
+    .map((property) => {
+      const traits = [
+        valueTypeLabels[property.valueType],
+        property.multiValued ? "list" : null,
+        property.computed ? "computed by a rule" : null,
+        property.unit ? `unit ${property.unit}` : null,
+        isPresent(property.allowedValues) ? `allowed values: ${property.allowedValues.join(", ")}` : null,
+      ].filter(isPresent);
+      return `- ${property.label} <${property.path}>: ${traits.join("; ")}`;
+    });
+  return [
+    `The rule is about memories of the "${schema.label}" memory schema <${schema.iri}>.`,
+    ...(isPresent(fields) ? ["Its fields:", ...fields] : []),
+  ].join("\n");
+}
+
+const numberTypes: readonly string[] = [GQLMemorySchemaValueType.Integer, GQLMemorySchemaValueType.Decimal];
+const dateTypes: readonly string[] = [GQLMemorySchemaValueType.Date, GQLMemorySchemaValueType.DateTime];
+
+export function memorySchemaRuleSuggestions(schema: Schema): string[] {
+  const name = schema.label;
+  const written = schema.properties.filter((property) => !property.computed);
+  const computed = schema.properties.find((property) => property.computed);
+  const key = written.find((property) => property.keyProperty);
+  const number = written.find((property) => numberTypes.includes(property.valueType));
+  const choice = written.find((property) => isPresent(property.options));
+  const date = written.find((property) => dateTypes.includes(property.valueType));
+  const firstChoice = choice?.options[0];
+
+  return [
+    computed ? `Fill in ${computed.label} on every ${name} memory from its other fields` : null,
+    number && key ? `For each ${key.label}, use the latest company ${name}'s ${number.label} as the target` : null,
+    number && !key ? `Use the latest company ${name}'s ${number.label} as the target` : null,
+    choice && firstChoice
+      ? `Flag company ${name} memories whose ${choice.label} is "${firstChoice.label ?? firstChoice.value}"`
+      : null,
+    date ? `Flag company ${name} memories whose ${date.label} is in the next 14 days` : null,
+  ]
+    .filter((suggestion): suggestion is string => suggestion !== null)
+    .slice(0, 3);
+}
+
+export function schemaRuleDraft(schema: Schema): RuleDraftRequest {
+  return {
+    key: schema.iri,
+    subject: { name: schema.label, context: memorySchemaRuleContext(schema) },
+    suggestions: memorySchemaRuleSuggestions(schema),
+  };
+}
+
+export function computedPropertyRuleDraft(schema: Schema, property: Property): RuleDraftRequest {
+  return {
+    key: `${schema.iri} ${property.path}`,
+    subject: {
+      name: `${property.label} on ${schema.label}`,
+      context: [
+        memorySchemaRuleContext(schema),
+        `The rule computes ${property.label} <${property.path}>, writing it onto the same memory it reads.`,
+      ].join("\n"),
+    },
+    suggestions: [`Fill in ${property.label} on every ${schema.label} memory from its other fields`],
+  };
+}
+
+type ExampleMemory = Pick<GQLMemory, "iri" | "label" | "customPropertyValues">;
+
+export function memoryRuleDraft(schema: Schema, memory: ExampleMemory): RuleDraftRequest {
+  const labelByPath = new Map(schema.properties.map((property) => [property.path, property.label]));
+  const values = memory.customPropertyValues
+    .filter(({ path, values: given }) => labelByPath.has(path) && isPresent(given))
+    .map(({ path, values: given }) => `- ${labelByPath.get(path)}: ${given.join(", ")}`);
+  return {
+    key: `${schema.iri} ${memory.iri}`,
+    subject: {
+      name: schema.label,
+      context: [
+        memorySchemaRuleContext(schema),
+        `An example company memory of this schema, "${memory.label}" <${memory.iri}>, holds:`,
+        ...(isPresent(values) ? values : ["- no field values yet"]),
+      ].join("\n"),
+    },
+    suggestions: memorySchemaRuleSuggestions(schema),
+  };
+}