@dxos/plugin-assistant 0.8.4-main.c4373fc → 0.8.4-main.d9fc60f731

package/src/components/SequenceEditor/index.ts

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

package/src/components/TemplateEditor/handlebars-extension.ts

@@ -1,165 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import {
-  type CompletionContext,
-  type CompletionResult,
-  autocompletion,
-  completionKeymap,
-} from '@codemirror/autocomplete';
-import { type Extension } from '@codemirror/state';
-import { Decoration, type DecorationSet, type EditorView, ViewPlugin, type ViewUpdate, keymap } from '@codemirror/view';
-
-export type HandlebarsOptions = {};
-
-/**
- * Simple Handlebars plugin for CodeMirror.
- * Supports:
- * - Comments: {{! comment }}
- * - Commands: {{#command}} {{/command}}
- * - Variables: {{var}}
- * - Commands with variables: {{#each items}} {{/each}}
- */
-export const handlebars = (_: HandlebarsOptions = {}): Extension => {
-  return [
-    handlebarsHighlightPlugin,
-    autocompletion({
-      activateOnTyping: true,
-      aboveCursor: true,
-      closeOnBlur: true,
-      override: [handlebarsCompletions],
-    }),
-    keymap.of(completionKeymap),
-  ];
-};
-
-const regex = {
-  comment: /\{\{!\s*[^}]*\}\}/g,
-  brackets: /\{\{[^}]*\}\}/g,
-  command: /\{\{[#/]([^}]+)\}\}/g,
-  var: /\{\{(?!\s*!)(\w[^}]*)\}\}/g,
-};
-
-/**
- * ViewPlugin that decorates Handlebars syntax.
- */
-const handlebarsHighlightPlugin = ViewPlugin.fromClass(
-  class {
-    decorations: DecorationSet;
-
-    constructor(view: EditorView) {
-      this.decorations = this.buildDecorations(view);
-    }
-
-    buildDecorations(view: EditorView) {
-      const widgets: any[] = [];
-
-      for (const { from, to } of view.visibleRanges) {
-        const text = view.state.doc.sliceString(from, to);
-
-        // Match comments: {{! comment }}
-        {
-          let match;
-          while ((match = regex.comment.exec(text)) !== null) {
-            const start = from + match.index;
-            const end = start + match[0].length;
-            widgets.push(Decoration.mark({ class: 'text-subdued' }).range(start, end));
-          }
-        }
-
-        // Match brackets: {{ and }}
-        {
-          let match;
-          while ((match = regex.brackets.exec(text)) !== null) {
-            const start = from + match.index;
-            const end = start + match[0].length;
-            widgets.push(Decoration.mark({ class: 'text-subdued' }).range(start, end));
-          }
-        }
-
-        // Match commands: {{#command}} and {{/command}}
-        {
-          let match;
-          while ((match = regex.command.exec(text)) !== null) {
-            const start = from + match.index + 2;
-            let end = start + match[0].length - 4;
-            const text = view.state.doc.sliceString(start, end);
-            const parts = text.split(/\s+/);
-            if (parts.length > 1) {
-              const idx = start + parts[0].length;
-              widgets.push(Decoration.mark({ class: 'text-greenText' }).range(idx, end));
-              end = idx;
-            }
-            widgets.push(Decoration.mark({ class: 'text-blueText' }).range(start, end));
-          }
-        }
-
-        // Match variables: {{var}}
-        {
-          let match;
-          while ((match = regex.var.exec(text)) !== null) {
-            const start = from + match.index + 2;
-            const end = start + match[0].length - 4;
-            widgets.push(Decoration.mark({ class: 'text-greenText' }).range(start, end));
-          }
-        }
-      }
-
-      // Sort decorations by position to avoid "Ranges must be added sorted" error.
-      widgets.sort((a, b) => a.from - b.from || a.startSide - b.startSide);
-      return Decoration.set(widgets);
-    }
-
-    update(update: ViewUpdate) {
-      if (update.docChanged || update.viewportChanged) {
-        this.decorations = this.buildDecorations(update.view);
-      }
-    }
-  },
-  {
-    decorations: (v) => v.decorations,
-  },
-);
-
-// TODO(burdon): Pass in variables.
-const variables = ['this'];
-const commands = ['this', 'each', 'if', 'unless', 'with'];
-
-/**
- * Provides completions for Handlebars variables.
- */
-function handlebarsCompletions(context: CompletionContext): CompletionResult | null {
-  const match = context.matchBefore(/\{\{[^}]*/);
-  if (!match || match.from === match.to) {
-    return null;
-  }
-
-  let type = 'variable';
-  let text = match.text.slice(2);
-  let from = match.from + 2;
-  let matches = [];
-  if (text.startsWith('#') || text.startsWith('/')) {
-    const idx = text.lastIndexOf(' ');
-    if (idx !== -1) {
-      type = 'variable';
-      matches = variables;
-      text = text.slice(idx + 1);
-      from += idx + 1;
-    } else {
-      type = 'command';
-      text = text.slice(1);
-      matches = commands;
-      from += 1;
-    }
-  } else {
-    type = 'variable';
-    matches = variables;
-  }
-
-  const options = matches.filter((name) => name.startsWith(text)).map((name) => ({ type, label: name }));
-  return {
-    from,
-    options,
-  };
-}

package/src/components/Toolbar/Toolbar.tsx

@@ -1,21 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React from 'react';
-
-import { fullyQualifiedId } from '@dxos/react-client/echo';
-import { type ThemedClassName } from '@dxos/react-ui';
-import { MenuProvider, ToolbarMenu } from '@dxos/react-ui-menu';
-
-import { type ChatToolbarActionsProps, useChatToolbarActions } from './useChatToolbarActions';
-
-export const Toolbar = ({ chat, companionTo, onReset, classNames }: ThemedClassName<ChatToolbarActionsProps>) => {
-  const menu = useChatToolbarActions({ chat, companionTo, onReset });
-
-  return (
-    <MenuProvider {...menu} attendableId={companionTo ? fullyQualifiedId(companionTo) : fullyQualifiedId(chat)}>
-      <ToolbarMenu classNames={classNames} />
-    </MenuProvider>
-  );
-};

package/src/components/Toolbar/useChatToolbarActions.ts

@@ -1,126 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Rx } from '@effect-rx/rx-react';
-import * as Effect from 'effect/Effect';
-import { useMemo } from 'react';
-
-import { createIntent, useIntentDispatcher } from '@dxos/app-framework';
-import { Filter, Obj, Query } from '@dxos/echo';
-import { invariant } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
-import { getSpace, useQuery } from '@dxos/react-client/echo';
-import { MenuBuilder, useMenuActions } from '@dxos/react-ui-menu';
-
-import { meta } from '../../meta';
-import { Assistant, AssistantAction } from '../../types';
-
-export type ChatToolbarActionsProps = {
-  chat: Assistant.Chat;
-  companionTo?: Obj.Any;
-  onReset?: () => void;
-};
-
-export const useChatToolbarActions = ({ chat, companionTo, onReset }: ChatToolbarActionsProps) => {
-  const { dispatch } = useIntentDispatcher();
-  const space = getSpace(chat);
-  const query = companionTo
-    ? Query.select(Filter.ids(companionTo.id)).targetOf(Assistant.CompanionTo).source()
-    : Query.select(Filter.nothing());
-  // TODO(wittjosiah): Query in react vs query in rx?
-  const chats = useQuery(space, query);
-
-  return useMenuActions(
-    useMemo(
-      () =>
-        Rx.make(() => {
-          const builder = MenuBuilder.make()
-            .root({
-              label: ['chat toolbar title', { ns: meta.id }],
-            })
-            .action(
-              'new',
-              {
-                label: ['button new thread', { ns: meta.id }],
-                icon: 'ph--plus--regular',
-                type: 'new',
-              },
-              () =>
-                Effect.gen(function* () {
-                  invariant(space);
-                  const { object } = yield* dispatch(createIntent(AssistantAction.CreateChat, { space }));
-                  yield* dispatch(createIntent(SpaceAction.AddObject, { object, target: space, hidden: true }));
-                  if (companionTo) {
-                    yield* dispatch(
-                      createIntent(SpaceAction.AddRelation, {
-                        space,
-                        schema: Assistant.CompanionTo,
-                        source: object,
-                        target: companionTo,
-                      }),
-                    );
-
-                    yield* dispatch(createIntent(AssistantAction.SetCurrentChat, { companionTo, chat: object }));
-                  }
-                }).pipe(Effect.runPromise),
-            )
-            .action(
-              'branch',
-              {
-                label: ['button branch thread', { ns: meta.id }],
-                icon: 'ph--git-branch--regular',
-                type: 'branch',
-                disabled: true,
-              },
-              () => {},
-            );
-
-          if (chats.length > 0) {
-            builder.group(
-              'chats',
-              {
-                label: ['chat history label', { ns: meta.id }],
-                icon: 'ph--clock-counter-clockwise--regular',
-                selectCardinality: 'single',
-                variant: 'dropdownMenu',
-              },
-              (builder) => {
-                chats
-                  // TODO(wittjosiah): This should be the default sort order.
-                  .toSorted((a, b) => a.id.localeCompare(b.id))
-                  .forEach((chat) => {
-                    builder.action(
-                      chat.id,
-                      {
-                        label: Obj.getLabel(chat) ?? ['object name placeholder', { ns: Assistant.Chat.typename }],
-                      },
-                      () =>
-                        Effect.gen(function* () {
-                          invariant(companionTo);
-                          yield* dispatch(createIntent(AssistantAction.SetCurrentChat, { companionTo, chat }));
-                        }).pipe(Effect.runPromise),
-                    );
-                  });
-              },
-            );
-          }
-
-          if (onReset) {
-            builder.action(
-              'reset',
-              {
-                label: ['button reset', { ns: meta.id }],
-                icon: 'ph--trash--regular',
-                type: 'reset',
-              },
-              onReset,
-            );
-          }
-
-          return builder.build();
-        }),
-      [chats],
-    ),
-  );
-};

package/src/events.ts

@@ -1,11 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { defineEvent } from '@dxos/app-framework';
-
-import { meta } from './meta';
-
-export namespace AssistantEvents {
-  export const SetupAiServiceProviders = defineEvent(`${meta.id}/event/setup-ai-service-providers`);
-}

package/src/functions/analysis.ts

@@ -1,22 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { defineFunction } from '@dxos/functions';
-import { log } from '@dxos/log';
-
-export default defineFunction({
-  key: 'dxos.org/function/assistant-analysis',
-  name: 'Assistant analysis',
-  description: 'Enter analysis analysis mode.',
-  inputSchema: Schema.Struct({
-    enable: Schema.Boolean.annotations({ description: 'Enable or disable analysis mode.' }),
-  }),
-  outputSchema: Schema.Void,
-  handler: Effect.fn(function* ({ context, data: { enable } }) {
-    log.info('analysis mode', { space: context.space?.id, enable });
-  }),
-});

package/src/functions/index.ts

@@ -1,7 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-export { default as analysis } from './analysis';
-export { default as list } from './list';
-export { default as load } from './load';

package/src/functions/list.ts

@@ -1,48 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Schema from 'effect/Schema';
-
-import { Filter, Obj, Query } from '@dxos/echo';
-import { DatabaseService, defineFunction } from '@dxos/functions';
-import { trim } from '@dxos/util';
-
-// TODO(burdon): Factor out to space plugin.
-export default defineFunction({
-  key: 'dxos.org/function/assistant/list',
-  name: 'Assistant list',
-  description:
-    // TODO(wittjosiah): Find a better way to prompt for looking up typenames before querying with them.
-    trim`
-      Lists the objects of the given type.
-      Check the list-schemas tool for available types before calling this function.
-    `,
-  inputSchema: Schema.Struct({
-    typename: Schema.String.annotations({
-      description: 'The typename of the objects to list.',
-    }),
-  }),
-  outputSchema: Schema.Struct({
-    results: Schema.Array(
-      Schema.Struct({
-        dxn: Schema.String.annotations({ description: 'The DXN of the object.' }),
-        label: Schema.optional(Schema.String.annotations({ description: 'The label of the object.' })),
-      }),
-    ),
-  }),
-  handler: Effect.fn(function* ({ data: { typename } }) {
-    // TODO(wittjosiah): Typename query is not working for dynamic schemas.
-    const [schema] = yield* DatabaseService.runSchemaQuery({ typename });
-    const filter = schema ? Filter.type(schema) : Filter.typename(typename);
-
-    const { objects } = yield* DatabaseService.runQuery(Query.select(filter));
-    const results = objects.map((object) => ({
-      dxn: Obj.getDXN(object).toString(),
-      label: Obj.getLabel(object),
-    }));
-
-    return { results };
-  }),
-});

package/src/functions/load.ts

@@ -1,46 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-import * as Function from 'effect/Function';
-import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
-
-import { ArtifactId } from '@dxos/assistant';
-import { Obj } from '@dxos/echo';
-import { DatabaseService, defineFunction } from '@dxos/functions';
-
-// TODO(burdon): Common error handling.
-// TODO(burdon): Factor out to space plugin.
-export default defineFunction({
-  key: 'dxos.org/function/assistant/load',
-  name: 'Assistant load',
-  description: 'Loads the object.',
-  inputSchema: Schema.Struct({
-    id: ArtifactId.annotations({
-      description: 'The ID of the object.',
-    }),
-    typename: Schema.String.annotations({
-      description: 'The typename of the object.',
-    }),
-  }),
-  outputSchema: Schema.Struct({
-    // TODO(wittjosiah): Type.Obj.Any | Type.Relation.Any
-    object: Schema.Any,
-  }),
-  handler: Effect.fn(function* ({ data: { id, typename } }) {
-    const object = yield* DatabaseService.resolve(ArtifactId.toDXN(id));
-    return yield* Function.pipe(
-      Option.fromNullable(object),
-      Option.flatMap((object) => (Obj.getTypename(object) === typename ? Option.some(object) : Option.none())),
-      Option.match({
-        onNone: () => Effect.fail('Object not found.'),
-        onSome: (object) => {
-          // log.info('object', { object });
-          return Effect.succeed({ object });
-        },
-      }),
-    );
-  }),
-});

package/src/hooks/useItemTypes.ts

@@ -1,37 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Option from 'effect/Option';
-import { useEffect, useState } from 'react';
-
-import { type Type } from '@dxos/echo';
-import { type Space } from '@dxos/react-client/echo';
-import { ItemAnnotation } from '@dxos/schema';
-
-// TODO(burdon): Pass in filter.
-export const useItemTypes = (space?: Space): Type.Obj.Any[] => {
-  const [types, setTypes] = useState<Type.Obj.Any[]>([]);
-  useEffect(() => {
-    if (!space) {
-      return;
-    }
-
-    return space.db.schemaRegistry.query().subscribe(
-      (query) => {
-        const types = Array.from(
-          new Set(
-            [...space.db.graph.schemaRegistry.schemas, ...query.results].filter((type) =>
-              Option.isSome(ItemAnnotation.get(type)),
-            ),
-          ),
-        );
-
-        setTypes(types);
-      },
-      { fire: true },
-    );
-  }, [space]);
-
-  return types;
-};

package/src/processor/processor.test.ts

@@ -1,81 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import * as Tool from '@effect/ai/Tool';
-import * as Toolkit from '@effect/ai/Toolkit';
-import { describe, it } from '@effect/vitest';
-import * as Effect from 'effect/Effect';
-import * as Layer from 'effect/Layer';
-import * as Schema from 'effect/Schema';
-
-import { AiService } from '@dxos/ai';
-import { AiServiceTestingPreset } from '@dxos/ai/testing';
-import { AiConversation, makeToolExecutionServiceFromFunctions, makeToolResolverFromFunctions } from '@dxos/assistant';
-import { TestHelpers } from '@dxos/effect';
-import {
-  ComputeEventLogger,
-  CredentialsService,
-  FunctionInvocationService,
-  QueueService,
-  TracingService,
-} from '@dxos/functions';
-import { TestDatabaseLayer } from '@dxos/functions/testing';
-import { type DataType } from '@dxos/schema';
-
-import { AiChatProcessor, type AiChatServices } from './processor';
-
-class TestToolkit extends Toolkit.make(
-  Tool.make('random', {
-    description: 'Random number generator',
-    parameters: {},
-    success: Schema.Number,
-  }),
-) {}
-
-// TODO(burdon): Create minimal toolkit.
-const toolkit = Toolkit.merge(TestToolkit) as Toolkit.Toolkit<any>;
-
-// TODO(burdon): Explain structure.
-const TestServicesLayer = Layer.mergeAll(
-  TracingService.layerNoop,
-  AiServiceTestingPreset('direct'),
-  TestDatabaseLayer({
-    // indexing: { vector: true },
-    // types: [],
-  }),
-  // CredentialsService.configuredLayer([{ service: 'exa.ai', apiKey: EXA_API_KEY }]),
-  FunctionInvocationService.layerTestMocked({ functions: [] }).pipe(
-    Layer.provideMerge(ComputeEventLogger.layerFromTracing),
-    Layer.provideMerge(TracingService.layerNoop),
-  ),
-);
-
-const TestLayer: Layer.Layer<AiChatServices, never, never> = Layer.mergeAll(
-  AiService.model('@anthropic/claude-opus-4-0'),
-  makeToolResolverFromFunctions([], toolkit),
-  makeToolExecutionServiceFromFunctions(toolkit, toolkit.toLayer({}) as any),
-  CredentialsService.layerFromDatabase(),
-  ComputeEventLogger.layerFromTracing,
-).pipe(Layer.provideMerge(TestServicesLayer), Layer.orDie);
-
-// TODO(burdon): Create actual test with mock LLM.
-describe('Chat processor', () => {
-  it.effect(
-    'basic',
-    Effect.fn(
-      function* ({ expect }) {
-        const services = yield* Effect.runtime<AiChatServices>();
-        const queue = yield* QueueService.createQueue<DataType.Message>();
-        const conversation = new AiConversation({ queue });
-        const processor = new AiChatProcessor(conversation, async () => services);
-        const result = yield* Effect.promise(() => processor.request({ message: 'Hello' }));
-        void processor.cancel();
-        expect(processor.active).to.be.false;
-        expect(result).to.exist;
-      },
-      Effect.provide(TestLayer),
-      TestHelpers.taggedTest('llm'),
-    ),
-  );
-});