@dxos/plugin-assistant 0.8.4-main.1da679c → 0.8.4-main.21d9917

package/src/capabilities/react-surface.tsx

@@ -1,91 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { Capabilities, contributes, createSurface } from '@dxos/app-framework';
-import { Blueprint } from '@dxos/blueprints';
-import { getSpace } from '@dxos/client/echo';
-import { Sequence } from '@dxos/conductor';
-import { InvocationTraceContainer } from '@dxos/devtools';
-import { Obj } from '@dxos/echo';
-import { SettingsStore } from '@dxos/local-storage';
-import { StackItem } from '@dxos/react-ui-stack';
-
-import {
-  AssistantSettings,
-  BlueprintContainer,
-  ChatCompanion,
-  ChatContainer,
-  ChatDialog,
-  PromptSettings,
-  SequenceContainer,
-} from '../components';
-import { ASSISTANT_DIALOG, meta } from '../meta';
-import { Assistant } from '../types';
-
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${meta.id}/plugin-settings`,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<Assistant.Settings> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
-      component: ({ data: { subject } }) => <AssistantSettings settings={subject.value} />,
-    }),
-    createSurface({
-      id: `${meta.id}/chat`,
-      role: 'article',
-      filter: (data): data is { subject: Assistant.Chat; variant: undefined } =>
-        Obj.instanceOf(Assistant.Chat, data.subject) && data.variant !== 'assistant-chat',
-      component: ({ data, role }) => <ChatContainer role={role} chat={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/companion-chat`,
-      role: 'article',
-      filter: (data): data is { companionTo: Obj.Any; subject: Assistant.Chat | 'assistant-chat' } =>
-        Obj.isObject(data.companionTo) &&
-        (Obj.instanceOf(Assistant.Chat, data.subject) || data.subject === 'assistant-chat'),
-      component: ({ data, role }) => <ChatCompanion role={role} data={data} />,
-    }),
-    createSurface({
-      id: `${meta.id}/sequence`,
-      role: 'article',
-      filter: (data): data is { subject: Sequence } => Obj.instanceOf(Sequence, data.subject),
-      component: ({ data }) => <SequenceContainer sequence={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/companion-logs`,
-      role: 'article',
-      filter: (data): data is { companionTo: Sequence } =>
-        Obj.instanceOf(Sequence, data.companionTo) && data.subject === 'logs',
-      // eslint-disable-next-line unused-imports/no-unused-vars
-      component: ({ data, role }) => {
-        const space = getSpace(data.companionTo);
-        return (
-          <StackItem.Content>
-            <InvocationTraceContainer space={space} target={data.companionTo} detailAxis='block' />
-          </StackItem.Content>
-        );
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/blueprint`,
-      role: 'article',
-      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
-      component: ({ data }) => <BlueprintContainer blueprint={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/prompt-settings`,
-      role: 'object-settings',
-      filter: (data): data is { subject: Blueprint.Blueprint } => Obj.instanceOf(Blueprint.Blueprint, data.subject),
-      component: ({ data }) => <PromptSettings template={data.subject.instructions} />,
-    }),
-    createSurface({
-      id: ASSISTANT_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: { chat: Assistant.Chat } } => data.component === ASSISTANT_DIALOG,
-      component: ({ data }) => <ChatDialog {...data.props} />,
-    }),
-  ]);

package/src/capabilities/settings.ts

@@ -1,19 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
-
-import { meta } from '../meta';
-import { Assistant } from '../types';
-
-export default () => {
-  const settings = live<Assistant.Settings>({});
-
-  return contributes(Capabilities.Settings, {
-    prefix: meta.id,
-    schema: Assistant.Settings,
-    value: settings,
-  });
-};

package/src/capabilities/state.ts

@@ -1,20 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { contributes } from '@dxos/app-framework';
-import { LocalStorageStore } from '@dxos/local-storage';
-
-import { meta } from '../meta';
-
-import { AssistantCapabilities } from './capabilities';
-
-export default () => {
-  // NOTE: This needs to be a chat object rather than a string id to avoid a query race.
-  // TODO(wittjosiah): Handle serialization and hydration for this so it can be cached.
-  const state = new LocalStorageStore<AssistantCapabilities.AssistantState>(meta.id, {
-    currentChat: {},
-  });
-
-  return contributes(AssistantCapabilities.State, state.values, () => state.close());
-};

package/src/capabilities/toolkit.ts

@@ -1,163 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { AiTool, AiToolkit } from '@effect/ai';
-import { Effect, Schema } from 'effect';
-
-import { Capabilities, type Capability, type PluginContext, contributes, createIntent } from '@dxos/app-framework';
-import { AiContextService, ArtifactId } from '@dxos/assistant';
-import { Filter, Obj, Ref, SchemaNotFoundError, Type } from '@dxos/echo';
-import { DatabaseService } from '@dxos/functions';
-import { invariant } from '@dxos/invariant';
-import { ClientCapabilities } from '@dxos/plugin-client';
-import { SpaceCapabilities, getActiveSpace } from '@dxos/plugin-space';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { DataType } from '@dxos/schema';
-import { trim } from '@dxos/util';
-
-// TODO(burdon): Reconcile with functions (currently reuses plugin framework intents).
-class Toolkit extends AiToolkit.make(
-  AiTool.make('add-to-context', {
-    description: trim`
-      Adds the object to the chat context.
-    `,
-    parameters: {
-      id: ArtifactId.annotations({
-        description: 'The ID of the document to read.',
-      }),
-    },
-    success: Schema.Void,
-    failure: Schema.Never,
-  }).addRequirement<AiContextService | DatabaseService>(), // TODO(burdon): Define standard contract.
-
-  AiTool.make('get-schemas', {
-    description: trim`
-      Retrieves schemas definitions.
-    `,
-    parameters: {
-      // TODO(wittjosiah): Remove this once parameter-less tools are fixed.
-      limit: Schema.Number,
-    },
-    // TODO(dmaretskyi): Effect returns ({ result, encodedResult })
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  AiTool.make('add-schema', {
-    description: trim`
-      Adds a schema to the space.
-      The name will be used when displayed to the user.
-      The typename must be in the format of "example.com/type/Type".
-    `,
-    parameters: {
-      name: Schema.String,
-      typename: Schema.String,
-      jsonSchema: Schema.Any,
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-
-  AiTool.make('create-record', {
-    description: trim`
-      Creates a new record and adds it to the current space.
-      Get the schema from the get-schemas tool and ensure that the data matches the corresponding schema.
-      Note that only record schemas are supported.
-    `,
-    parameters: {
-      typename: Schema.String,
-      data: Schema.Any,
-    },
-    success: Schema.Any,
-    failure: Schema.Never,
-  }),
-) {
-  static layer = (context: PluginContext) =>
-    Toolkit.toLayer({
-      'add-to-context': Effect.fnUntraced(function* ({ id }) {
-        const { binder } = yield* AiContextService;
-        const { db } = yield* DatabaseService;
-        const ref = Ref.fromDXN(ArtifactId.toDXN(id, db.spaceId));
-        yield* Effect.promise(() =>
-          binder.bind({
-            blueprints: [],
-            objects: [ref],
-          }),
-        );
-      }),
-
-      'get-schemas': () => {
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const whitelist = context
-            .getCapabilities(ClientCapabilities.SchemaWhiteList)
-            .flat()
-            .map((schema) => ({
-              typename: Type.getTypename(schema),
-              jsonSchema: Type.toJsonSchema(schema),
-              kind: 'record',
-            }));
-
-          // TODO(burdon): Why ObjectForm (bad name for data capability; UI term)?
-          const forms = context.getCapabilities(SpaceCapabilities.ObjectForm).map((form) => ({
-            typename: Type.getTypename(form.objectSchema),
-            jsonSchema: Type.toJsonSchema(form.objectSchema),
-            kind: 'item',
-          }));
-
-          const schemas = [...whitelist, ...forms];
-          if (space) {
-            const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-            schemas.push(
-              ...objects.map((object) => ({
-                typename: object.typename,
-                jsonSchema: object.jsonSchema,
-                kind: 'record',
-              })),
-            );
-          }
-
-          return schemas;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)));
-      },
-
-      'add-schema': ({ name, typename, jsonSchema }) => {
-        return Effect.gen(function* () {
-          const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-          const space = getActiveSpace(context);
-          invariant(space, 'No active space');
-
-          const schema = Type.toEffectSchema(jsonSchema).pipe(Type.Obj({ typename, version: '0.1.0' }));
-          yield* dispatch(createIntent(SpaceAction.AddSchema, { space, name, typename, schema }));
-        }).pipe(Effect.orDie);
-      },
-
-      'create-record': ({ typename, data }) => {
-        const { dispatch } = context.getCapability(Capabilities.IntentDispatcher);
-        const space = getActiveSpace(context);
-        invariant(space, 'No active space');
-
-        return Effect.gen(function* () {
-          const schemas = context.getCapabilities(ClientCapabilities.SchemaWhiteList).flat();
-          const { objects } = yield* DatabaseService.runQuery(Filter.type(DataType.StoredSchema));
-          schemas.push(...objects.map((object) => Type.toEffectSchema(object.jsonSchema)));
-          const schema = schemas.find((schema) => Type.getTypename(schema) === typename);
-          if (!schema) {
-            throw new SchemaNotFoundError(typename);
-          }
-
-          const object = Obj.make(schema, data);
-          yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-          return object;
-        }).pipe(Effect.provide(DatabaseService.layer(space.db)), Effect.orDie);
-      },
-    });
-}
-
-export default (context: PluginContext): Capability<any>[] => [
-  contributes(Capabilities.Toolkit, Toolkit),
-  contributes(Capabilities.ToolkitHandler, Toolkit.layer(context)),
-];

package/src/components/BlueprintContainer.tsx

@@ -1,24 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { type Blueprint } from '@dxos/blueprints';
-import { StackItem } from '@dxos/react-ui-stack';
-
-import { TemplateEditor } from './TemplateEditor';
-
-export type BlueprintContainerProps = {
-  blueprint: Blueprint.Blueprint;
-};
-
-export const BlueprintContainer = ({ blueprint }: BlueprintContainerProps) => {
-  return (
-    <StackItem.Content classNames='container-max-width'>
-      <TemplateEditor id={blueprint.id} template={blueprint.instructions} />
-    </StackItem.Content>
-  );
-};
-
-export default BlueprintContainer;

package/src/components/PromptSettings.tsx

@@ -1,90 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { type Template } from '@dxos/blueprints';
-import { Toolbar, useTranslation } from '@dxos/react-ui';
-
-import { meta } from '../meta';
-
-export const PromptSettings = ({ template }: { template: Template.Template }) => {
-  const { t } = useTranslation(meta.id);
-
-  // const handleKindChange = useCallback(
-  //   (value: string) => {
-  //     const kind = Match.type<string>().pipe(
-  //       Match.withReturnType<Schema.Schema.Type<typeof Template.Template>>(),
-  //       Match.when('always', () => ({ include: 'always' })),
-  //       Match.when('schema-matching', () => ({ include: 'schema-matching', typename: '' })),
-  //       Match.when('automatically', () => ({ include: 'automatically', description: '' })),
-  //       Match.orElse(() => ({ include: 'manual' })),
-  //     )(value);
-  //
-  //     template.kind = kind;
-  //   },
-  //   [template],
-  // );
-
-  // const handleTypenameChange = useCallback(
-  //   debounce((event: ChangeEvent<HTMLInputElement>) => {
-  //     if (template.kind.include === 'schema-matching') {
-  //       template.kind.typename = event.target.value;
-  //     }
-  //   }, 300),
-  //   [template.kind.include],
-  // );
-
-  // const handleDescriptionChange = useCallback(
-  //   debounce((event: ChangeEvent<HTMLInputElement>) => {
-  //     if (template.kind.include === 'automatically') {
-  //       template.kind.description = event.target.value;
-  //     }
-  //   }, 300),
-  //   [template.kind.include],
-  // );
-
-  return (
-    <div className='flex flex-col gap-4'>
-      <h2>{t('prompt rules label')}</h2>
-      <Toolbar.Root>
-        {/* <Select.Root value={template.kind.include} onValueChange={handleKindChange}>
-          <Toolbar.Button asChild>
-            <Select.TriggerButton />
-          </Toolbar.Button>
-          <Select.Portal>
-            <Select.Content>
-              <Select.Viewport>
-                {Template.Kinds.map((kind) => (
-                  <Select.Option key={kind} value={kind}>
-                    {kind}
-                  </Select.Option>
-                ))}
-              </Select.Viewport>
-              <Select.Arrow />
-            </Select.Content>
-          </Select.Portal>
-        </Select.Root> */}
-        {/* {template.kind.include === 'schema-matching' && (
-          <Input.Root>
-            <Input.TextInput
-              placeholder={t('typename placeholder')}
-              defaultValue={template.kind.typename}
-              onChange={handleTypenameChange}
-            />
-          </Input.Root>
-        )} */}
-        {/* {template.kind.include === 'automatically' && (
-          <Input.Root>
-            <Input.TextInput
-              placeholder={t('description placeholder')}
-              defaultValue={template.kind.description}
-              onChange={handleDescriptionChange}
-            />
-          </Input.Root>
-        )} */}
-      </Toolbar.Root>
-    </div>
-  );
-};

package/src/components/SequenceContainer.tsx

@@ -1,131 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type EditorView } from '@codemirror/view';
-import JSON5 from 'json5';
-import React, { useCallback, useEffect, useRef, useState } from 'react';
-
-import { type Sequence, type SequenceDefinition } from '@dxos/conductor';
-import { Key } from '@dxos/echo';
-import { Toolbar, useTranslation } from '@dxos/react-ui';
-import { useSelectionManager } from '@dxos/react-ui-attention';
-import { StackItem } from '@dxos/react-ui-stack';
-
-import { meta } from '../meta';
-
-import { SequenceEditor } from './SequenceEditor';
-
-// TODO(burdon): Move to config.
-export const EXA_API_KEY = '9c7e17ff-0c85-4cd5-827a-8b489f139e03';
-
-// TODO(burdon): Validate.
-const parseSequence = (text: string): SequenceDefinition | undefined => {
-  try {
-    const json = JSON5.parse(text);
-    const { steps } = json;
-    return { steps };
-  } catch (error) {
-    // Ignore.
-  }
-};
-
-export const SequenceContainer = ({ sequence }: { sequence: Sequence }) => {
-  const { t } = useTranslation(meta.id);
-  const selectionManager = useSelectionManager();
-  const [definition, setDefinition] = useState<SequenceDefinition>();
-  useEffect(() => {
-    setDefinition({
-      steps: sequence.steps.map(({ instructions, tools }) => ({ instructions, tools })),
-    });
-  }, [sequence]);
-
-  const editorRef = useRef<EditorView | undefined>(undefined);
-
-  // TODO(burdon): Factor out.
-  // const toolRegistry = useMemo(() => {
-  //   const space = getSpace(sequence);
-  //   if (!space) {
-  //     return;
-  //   }
-
-  //   // TODO(burdon): How should the queue be created?
-  //   // eslint-disable-next-line no-unused-vars
-  //   const _queue = space.queues.create();
-
-  //   return new ToolRegistry([
-  //     // createExaTool({ apiKey: EXA_API_KEY }),
-  //     // createLocalSearchTool(space.db, queue),
-  //     // createGraphWriterTool({
-  //     //   db: space.db,
-  //     //   queue,
-  //     //   schema: [], // TODO(burdon): Get schema from client/sequence?
-  //     //   onDone: async (objects) => {
-  //     //     await queue.append(objects);
-  //     //   },
-  //     // }),
-  //   ]);
-  // }, [sequence]);
-
-  const formatAndSave = useCallback((): SequenceDefinition | undefined => {
-    if (!sequence) {
-      return;
-    }
-
-    const text = editorRef.current?.state.doc.toString();
-    if (!text) {
-      return;
-    }
-
-    const definition = parseSequence(text);
-    if (!definition) {
-      return;
-    }
-
-    setDefinition(definition);
-    const formatted = JSON.stringify(definition, null, 2);
-    editorRef.current?.dispatch({
-      changes: { from: 0, to: text.length, insert: formatted },
-    });
-
-    sequence.steps.length = 0;
-    for (const step of definition.steps) {
-      sequence.steps.push({
-        id: Key.ObjectId.random(),
-        instructions: step.instructions,
-        tools: step.tools,
-      });
-    }
-
-    return sequence;
-  }, [sequence]);
-
-  // TODO(burdon): Save raw sequence separately from parsed sequence? (like Script).
-  const handleSave = useCallback(() => formatAndSave(), [formatAndSave]);
-
-  const handleRun = useCallback(async () => {
-    // if (!aiClient?.value || !toolRegistry) {
-    //   return;
-    // }
-    // formatAndSave();
-    // // Get input from selection.
-    // const input = Array.from(getSelectionSet(selectionManager)).map((id) => DXN.fromLocalObjectId(id));
-    // if (!input.length) {
-    //   return;
-    // }
-    // const machine = new SequenceMachine(toolRegistry, sequence).setLogger(new QueueLogger(sequence));
-    // await machine.runToCompletion({ aiClient: aiClient.value, input });
-  }, [sequence, formatAndSave, selectionManager]);
-
-  return (
-    <StackItem.Content toolbar>
-      <Toolbar.Root>
-        <Toolbar.Button onClick={handleSave}>{t('button save')}</Toolbar.Button>
-        <Toolbar.Button onClick={handleRun}>{t('button run')}</Toolbar.Button>
-      </Toolbar.Root>
-      {definition && <SequenceEditor ref={editorRef} sequence={definition} />}
-    </StackItem.Content>
-  );
-};
-
-export default SequenceContainer;

package/src/components/SequenceEditor/SequenceEditor.stories.tsx

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import '@dxos-theme';
-
-import { type Meta, type StoryObj } from '@storybook/react-vite';
-
-import { withLayout, withTheme } from '@dxos/storybook-utils';
-
-import { RESEARCH_SEQUENCE_DEFINITION } from '../../testing';
-import { translations } from '../../translations';
-
-import { SequenceEditor } from './SequenceEditor';
-
-const meta = {
-  title: 'plugins/plugin-assistant/SequenceEditor',
-  component: SequenceEditor,
-  decorators: [withTheme, withLayout({ fullscreen: true, classNames: 'mli-auto max-is-[50rem] justify-center' })],
-  parameters: {
-    translations,
-  },
-} satisfies Meta<typeof SequenceEditor>;
-
-export default meta;
-
-type Story = StoryObj<typeof SequenceEditor>;
-
-export const Default: Story = {
-  args: {
-    sequence: RESEARCH_SEQUENCE_DEFINITION,
-  },
-};

package/src/components/SequenceEditor/SequenceEditor.tsx

@@ -1,50 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React, { forwardRef, useImperativeHandle } from 'react';
-
-import { SequenceDefinition } from '@dxos/conductor';
-import { Type } from '@dxos/echo';
-import { type ThemedClassName, useThemeContext } from '@dxos/react-ui';
-import {
-  type EditorView,
-  createBasicExtensions,
-  createJsonExtensions,
-  createThemeExtensions,
-  useTextEditor,
-} from '@dxos/react-ui-editor';
-import { mx } from '@dxos/react-ui-theme';
-
-export type SequenceEditorProps = ThemedClassName<{
-  sequence: SequenceDefinition;
-}>;
-
-// TODO(burdon): Factor out JsonEditor.
-export const SequenceEditor = forwardRef<EditorView | undefined, SequenceEditorProps>(
-  ({ classNames, sequence }, forwardedRef) => {
-    const { themeMode } = useThemeContext();
-    const { parentRef, view } = useTextEditor({
-      initialValue: JSON.stringify(sequence, null, 2),
-      extensions: [
-        createBasicExtensions({
-          lineNumbers: true,
-          lineWrapping: false,
-          monospace: true,
-          scrollPastEnd: true,
-        }),
-        createThemeExtensions({
-          themeMode,
-          syntaxHighlighting: true,
-        }),
-        createJsonExtensions({
-          schema: Type.toJsonSchema(SequenceDefinition, { strict: true }),
-        }),
-      ],
-    });
-
-    useImperativeHandle(forwardedRef, () => view, [view]);
-
-    return <div ref={parentRef} className={mx('overflow-hidden', classNames)} />;
-  },
-);

package/src/components/SequenceEditor/index.ts

@@ -1,5 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export * from './SequenceEditor';