@dxos/plugin-automation 0.6.14-main.1366248

package/src/components/TriggerEditor/meta.tsx

@@ -0,0 +1,225 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { type FC } from 'react';
+
+import { create, getMeta as getEchoMeta } from '@dxos/echo-schema';
+import { type FunctionTrigger } from '@dxos/functions/types';
+import { GameType } from '@dxos/plugin-chess/types';
+import { FileType } from '@dxos/plugin-ipfs/types';
+import { DocumentType } from '@dxos/plugin-markdown';
+import { type ScriptType } from '@dxos/plugin-script';
+import { DiagramType } from '@dxos/plugin-sketch/types';
+import { CollectionType, MessageType } from '@dxos/plugin-space';
+import { Input } from '@dxos/react-ui';
+import { safeParseInt } from '@dxos/util';
+
+import { InputRow } from './Form';
+import { chainPresets } from '../../presets';
+import { type ChainPromptType } from '../../types';
+import { ChainPresets } from '../Chain';
+import { PromptEditor } from '../PromptEditor';
+
+// TODO(burdon): Factor out deps (remove from package.json). Provide via plugins.
+
+type TriggerId = string;
+
+const stateInitialValues = {
+  schemas: [
+    // TODO(burdon): Get all schema from API.
+    DocumentType,
+    FileType,
+    GameType,
+    MessageType,
+    DiagramType,
+    CollectionType,
+  ] as any[],
+  selectedSchema: {} as Record<TriggerId, any>,
+};
+
+// TODO(burdon): What is this for?
+export const state = create<typeof stateInitialValues>(stateInitialValues);
+
+//
+// Trigger meta.
+// TODO(burdon): Custom/generated UX to provide values to functions from types/other metadata.
+//
+
+type MetaProps<T> = { meta: T } & { triggerId?: string };
+
+type MetaExtension<T> = {
+  initialValue?: () => T;
+  component: FC<MetaProps<T>>;
+};
+
+const USERFUNCTIONS_PRESET_META_KEY = 'dxos.org/service/function-preset';
+
+/**
+ * Create meta type from function.
+ * @param trigger - function trigger.
+ * @param script - function script.
+ */
+export const getFunctionMetaExtension = (
+  trigger: FunctionTrigger,
+  script?: ScriptType,
+): MetaExtension<any> | undefined => {
+  if (script) {
+    const meta = getEchoMeta(script).keys.find((key) => key.source === USERFUNCTIONS_PRESET_META_KEY);
+    const extension = meta && metaExtensions[meta.id];
+    if (extension) {
+      return extension;
+    }
+  }
+  // TODO: try to infer by spec type?
+  return trigger?.function ? metaExtensions[trigger.function] : metaExtensions['dxos.org/function/gpt'];
+};
+
+//
+// Default (generic).
+// TODO(burdon): Create property editor.
+//
+
+type DefaultMeta = {};
+
+const DefaultMetaProps = ({ meta }: MetaProps<DefaultMeta>) => {
+  return <></>;
+};
+
+//
+// Chess
+//
+
+type ChessMeta = { level?: number };
+
+const ChessMetaProps = ({ meta }: MetaProps<ChessMeta>) => {
+  if (!meta) {
+    return null;
+  }
+
+  return (
+    <>
+      <InputRow label='Level'>
+        <Input.TextInput
+          type='number'
+          value={meta.level ?? 1}
+          onChange={(event) => (meta.level = safeParseInt(event.target.value))}
+          placeholder='Engine strength.'
+        />
+      </InputRow>
+    </>
+  );
+};
+
+//
+// Email
+//
+
+type EmailWorkerMeta = { account?: string };
+
+const EmailWorkerMetaProps = ({ meta }: MetaProps<EmailWorkerMeta>) => {
+  if (!meta) {
+    return null;
+  }
+
+  return (
+    <>
+      <InputRow label='Account'>
+        <Input.TextInput
+          value={meta.account ?? ''}
+          onChange={(event) => (meta.account = event.target.value)}
+          placeholder='https://'
+        />
+      </InputRow>
+    </>
+  );
+};
+
+//
+// Chain
+//
+
+type ChainPromptMeta = { model?: string; prompt?: ChainPromptType };
+
+const ChainPromptMetaProps = ({ meta, triggerId }: MetaProps<ChainPromptMeta>) => {
+  const schema = triggerId ? state.selectedSchema[triggerId] : undefined;
+  if (!meta) {
+    return null;
+  }
+
+  return (
+    <>
+      <InputRow label='Model'>
+        <Input.TextInput
+          value={meta.model ?? ''}
+          onChange={(event) => (meta.model = event.target.value)}
+          placeholder='llama2'
+        />
+      </InputRow>
+      <InputRow label='Presets'>
+        <ChainPresets
+          presets={chainPresets}
+          onSelect={(preset) => {
+            meta.prompt = preset.createPrompt();
+          }}
+        />
+      </InputRow>
+      {meta.prompt && (
+        <InputRow label='Prompt'>
+          <PromptEditor prompt={meta.prompt} schema={schema} />
+        </InputRow>
+      )}
+    </>
+  );
+};
+
+//
+// Embedding
+//
+
+type EmbeddingMeta = { model?: string; prompt?: ChainPromptType };
+
+const EmbeddingMetaProps = ({ meta }: MetaProps<EmbeddingMeta>) => {
+  if (!meta) {
+    return null;
+  }
+
+  return (
+    <>
+      <InputRow label='Model'>
+        <Input.TextInput
+          value={meta.model ?? ''}
+          onChange={(event) => (meta.model = event.target.value)}
+          placeholder='llama2'
+        />
+      </InputRow>
+    </>
+  );
+};
+
+const metaExtensions: Record<string, MetaExtension<any>> = {
+  __DEFAULT__: {
+    initialValue: () => ({}),
+    component: DefaultMetaProps,
+  } satisfies MetaExtension<DefaultMeta>,
+
+  'dxos.org/function/chess': {
+    initialValue: () => ({ level: 2 }),
+    component: ChessMetaProps,
+  } satisfies MetaExtension<ChessMeta>,
+
+  'dxos.org/function/email-worker': {
+    initialValue: () => ({ account: 'hello@dxos.network' }),
+    component: EmailWorkerMetaProps,
+  } satisfies MetaExtension<EmailWorkerMeta>,
+
+  'dxos.org/function/gpt': {
+    initialValue: () => ({ model: 'llama2' }),
+    component: ChainPromptMetaProps,
+  } satisfies MetaExtension<ChainPromptMeta>,
+
+  'dxos.org/function/embedding': {
+    initialValue: () => ({ model: 'llama2' }),
+    component: EmbeddingMetaProps,
+  } satisfies MetaExtension<EmbeddingMeta>,
+};

package/src/components/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { lazy } from 'react';
+
+export const PromptContainer = lazy(() => import('./PromptContainer'));
+
+export * from './AutomationPanel';
+export * from './Chain';
+export * from './PromptEditor';
+export * from './TriggerEditor';

package/src/index.ts

@@ -0,0 +1,12 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { AutomationPlugin } from './AutomationPlugin';
+
+export default AutomationPlugin;
+
+export * from './AutomationPlugin';
+export * from './components';
+export * from './presets';
+export * from './types';

package/src/meta.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type PluginMeta } from '@dxos/app-framework';
+
+export const AUTOMATION_PLUGIN = 'dxos.org/plugin/automation';
+
+export default {
+  id: AUTOMATION_PLUGIN,
+  name: 'Automation',
+  description: 'Automation workflows.',
+  icon: 'ph--flow-arrow--regular',
+  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/experimental/plugin-automation',
+  tags: ['experimental'],
+} satisfies PluginMeta;

package/src/presets.ts

@@ -0,0 +1,248 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { create } from '@dxos/echo-schema';
+
+import { ChainInputType, ChainPromptType } from './types';
+
+export const str = (...text: (string | undefined | boolean)[]): string =>
+  text
+    .filter((value) => value !== undefined && value !== false)
+    .flat()
+    .join('\n');
+
+export type Preset = {
+  id: string;
+  title: string;
+  createPrompt: () => ChainPromptType;
+};
+
+export const chainPresets: Preset[] = [
+  {
+    id: 'dxos.org/prompt/translate',
+    title: 'Translate',
+    createPrompt: () =>
+      create(ChainPromptType, {
+        command: 'say',
+        template: str(
+          // prettier-ignore
+          'Translate the following into {language}:',
+          '',
+          '---',
+          '',
+          '{input}',
+        ),
+        inputs: [
+          {
+            type: ChainInputType.VALUE,
+            name: 'language',
+            value: 'japanese',
+          },
+          {
+            type: ChainInputType.PASS_THROUGH,
+            name: 'input',
+          },
+          // TODO(burdon): Message.
+          // {
+          //   type: ChainInputType.CONTEXT,
+          //   name: 'input',
+          //   value: 'object.text',
+          // },
+        ],
+      }),
+  },
+  {
+    id: 'dxos.org/prompt/chess',
+    title: 'Chess',
+    createPrompt: () =>
+      create(ChainPromptType, {
+        command: 'hint',
+        template: str(
+          // prettier-ignore
+          'You are a machine that is an expert chess player.',
+          '',
+          'The move history of the current game is: {history}',
+          '',
+          'Suggest the next move and very briefly explain your strategy in a couple of sentences.',
+        ),
+        inputs: [
+          {
+            type: ChainInputType.CONTEXT,
+            name: 'history',
+            value: 'object.pgn',
+          },
+        ],
+      }),
+  },
+  {
+    id: 'dxos.org/prompt/mermaid',
+    title: 'Mermaid',
+    createPrompt: () =>
+      create(ChainPromptType, {
+        command: 'draw',
+        template: str(
+          // prettier-ignore
+          'Create a simplified mermaid graph representing the text below.',
+          'Do not explain anything.',
+          '',
+          '---',
+          '',
+          '{input}',
+        ),
+        inputs: [
+          {
+            type: ChainInputType.PASS_THROUGH,
+            name: 'input',
+          },
+        ],
+      }),
+  },
+  {
+    id: 'dxos.org/prompt/list',
+    title: 'List',
+    createPrompt: () =>
+      create(ChainPromptType, {
+        command: 'list',
+        template: str(
+          // prettier-ignore
+          'You are a machine that only replies with valid, iterable RFC8259 compliant JSON in your responses.',
+          'Your entire response should be a single array of JSON objects.',
+          '',
+          'Your entire response should be a map where the key is the type and the value is a single array of JSON objects conforming to the following types:',
+          '',
+          '{schema}',
+          '',
+          '---',
+          '',
+          '{question}',
+        ),
+        inputs: [
+          {
+            type: ChainInputType.SCHEMA,
+            name: 'schema',
+            value: 'example.com/type/project',
+          },
+          {
+            type: ChainInputType.PASS_THROUGH,
+            name: 'question',
+          },
+        ],
+      }),
+  },
+  {
+    id: 'dxos.org/prompt/base',
+    title: 'RAG',
+    createPrompt: () =>
+      create(ChainPromptType, {
+        command: 'rag',
+        template: str(
+          // prettier-ignore
+          "Very briefly answer the question based only on the following context and say if you don't know the answer.",
+          // 'answer the question using the following context as well as your training data:',
+          '',
+          '{context}',
+          '',
+          '---',
+          '',
+          'question: {question}',
+        ),
+        inputs: [
+          {
+            type: ChainInputType.RETRIEVER,
+            name: 'context',
+          },
+          {
+            type: ChainInputType.CONTEXT,
+            name: 'question',
+            value: 'object.text',
+          },
+        ],
+      }),
+  },
+  {
+    id: 'dxos.org/prompt/lookup',
+    title: 'Lookup',
+    createPrompt: () =>
+      create(ChainPromptType, {
+        command: 'lookup',
+        template: str(
+          // prettier-ignore
+          'Lookup and very briefly summarize the following topic in one or two sentences:',
+          '',
+          '---',
+          '',
+          '{input}',
+        ),
+        inputs: [
+          {
+            type: ChainInputType.CONTEXT,
+            name: 'input',
+            value: 'text',
+          },
+        ],
+      }),
+  },
+  {
+    id: 'dxos.org/prompt/extract',
+    title: 'Extract',
+    createPrompt: () =>
+      create(ChainPromptType, {
+        command: 'extract',
+        template: str(
+          // prettier-ignore
+          'List all people and companies mentioned in the text below.',
+          '',
+          'You are a machine that only replies with valid, iterable RFC8259 compliant JSON in your responses.',
+          'Your entire response should be a map where the key is the type and the value is a single array of JSON objects conforming to the following types:',
+          '',
+          '{contact}',
+          '{company}',
+          '',
+          '---',
+          '',
+          '{input}',
+        ),
+        inputs: [
+          {
+            type: ChainInputType.SCHEMA,
+            name: 'contact',
+            value: 'example.com/type/contact',
+          },
+          {
+            type: ChainInputType.SCHEMA,
+            name: 'company',
+            value: 'example.com/type/organization',
+          },
+          {
+            type: ChainInputType.CONTEXT,
+            name: 'input',
+            value: 'text',
+          },
+        ],
+      }),
+  },
+  {
+    id: 'dxos.org/prompt/discord',
+    title: 'Summarize',
+    createPrompt: () =>
+      create(ChainPromptType, {
+        command: 'summarize',
+        template: str(
+          // prettier-ignore
+          'Summarize what the team is working on and format it as a markdown table without any explanation.',
+          '',
+          '---',
+          '',
+          '{context}',
+        ),
+        inputs: [
+          {
+            type: ChainInputType.RESOLVER,
+            name: 'context',
+            value: 'discord.messages.recent',
+          },
+        ],
+      }),
+  },
+];

package/src/translations.ts

@@ -0,0 +1,31 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { AUTOMATION_PLUGIN } from './meta';
+
+export default [
+  {
+    'en-US': {
+      [AUTOMATION_PLUGIN]: {
+        'plugin name': 'Automation',
+        'object placeholder': 'New prompt',
+        'create object label': 'Create prompt',
+        'create trigger label': 'Create trigger',
+        'create stack section label': 'Create prompt',
+        'command placeholder': 'Enter slash command...',
+        'template placeholder': 'Enter template...',
+        'value placeholder': 'Enter value...',
+        'select preset template placeholder': 'Select preset',
+        'open automation panel label': 'Show Automations',
+
+        // 'create object label': 'Create rule',
+        // 'create stack section label': 'Create rule',
+        // 'command placeholder': 'Enter command...',
+        // 'template placeholder': 'Enter template...',
+        // 'value placeholder': 'Enter value...',
+        // 'select preset template placeholder': 'Select preset',
+      },
+    },
+  },
+];

package/src/types/chain.ts

@@ -0,0 +1,38 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { ref, S, TypedObject } from '@dxos/echo-schema';
+
+// TODO(burdon): Change to S.Literal (and discriminated union).
+export enum ChainInputType {
+  VALUE = 0,
+  PASS_THROUGH = 1,
+  RETRIEVER = 2,
+  FUNCTION = 3,
+  QUERY = 4,
+  RESOLVER = 5,
+  CONTEXT = 6,
+  SCHEMA = 7,
+}
+
+export const ChainInputSchema = S.mutable(
+  S.Struct({
+    name: S.String,
+    type: S.optional(S.Enums(ChainInputType)),
+    value: S.optional(S.String),
+  }),
+);
+
+export type ChainInput = S.Schema.Type<typeof ChainInputSchema>;
+
+export class ChainPromptType extends TypedObject({ typename: 'dxos.org/type/ChainPrompt', version: '0.1.0' })({
+  command: S.optional(S.String),
+  template: S.String,
+  inputs: S.optional(S.mutable(S.Array(ChainInputSchema))),
+}) {}
+
+export class ChainType extends TypedObject({ typename: 'dxos.org/type/Chain', version: '0.1.0' })({
+  name: S.optional(S.String),
+  prompts: S.optional(S.mutable(S.Array(ref(ChainPromptType)))),
+}) {}

package/src/types/index.ts

@@ -0,0 +1,6 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './chain';
+export * from './types';

package/src/types/types.ts

@@ -0,0 +1,29 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import type {
+  GraphBuilderProvides,
+  IntentResolverProvides,
+  MetadataRecordsProvides,
+  SurfaceProvides,
+  TranslationsProvides,
+} from '@dxos/app-framework';
+import { type SchemaProvides } from '@dxos/plugin-client';
+import { type PanelProvides } from '@dxos/plugin-deck/types';
+
+import { AUTOMATION_PLUGIN } from '../meta';
+
+const AUTOMATION_ACTION = `${AUTOMATION_PLUGIN}/action`;
+
+export enum AutomationAction {
+  CREATE = `${AUTOMATION_ACTION}/create`,
+}
+
+export type AutomationPluginProvides = SurfaceProvides &
+  IntentResolverProvides &
+  MetadataRecordsProvides &
+  TranslationsProvides &
+  GraphBuilderProvides &
+  SchemaProvides &
+  PanelProvides;