@dxos/plugin-assistant 0.8.2-main.fbd8ed0 → 0.8.2-staging.42af850

package/src/hooks/useContextProvider.ts

@@ -7,7 +7,7 @@ import { useMemo } from 'react';
 
 import { Capabilities, useCapabilities } from '@dxos/app-framework';
 import { Filter, type Space } from '@dxos/client/echo';
-import { Type } from '@dxos/echo';
+import { Obj } from '@dxos/echo';
 import { type BaseEchoObject, getDXN, getLabel } from '@dxos/echo-schema';
 import { log } from '@dxos/log';
 
@@ -35,23 +35,23 @@ export const useContextProvider = (space?: Space): ContextProvider | undefined =
         return (
           objects
             .map((object) => {
-              log.info('object', { object, label: getLabel(Type.getSchema(object)!, object) });
+              log.info('object', { object, label: getLabel(Obj.getSchema(object)!, object) });
               return object;
             })
-            .filter((object) => stringMatch(query, getLabel(Type.getSchema(object)!, object) ?? ''))
+            .filter((object) => stringMatch(query, getLabel(Obj.getSchema(object)!, object) ?? ''))
             // TODO(dmaretskyi): `Type.getDXN` (at the point of writing) didn't work here as it was schema-only.
             .filter((object) => !!getDXN(object))
             .map((object) => ({
               uri: getDXN(object as any)!.toString(),
-              label: getLabel(Type.getSchema(object)!, object) ?? '',
+              label: getLabel(Obj.getSchema(object)!, object) ?? '',
             }))
         );
       },
       resolveMetadata: async ({ uri }) => {
-        const object = await space.db.query({ id: uri }).first();
+        const object = await space.db.query(Filter.ids(uri)).first();
         return {
           uri,
-          label: getLabel(Type.getSchema(object)!, object) ?? '',
+          label: getLabel(Obj.getSchema(object)!, object) ?? '',
         };
       },
     };

package/src/hooks/useMessageQueue.ts

@@ -4,7 +4,7 @@
 
 import { useMemo } from 'react';
 
-import { type Message } from '@dxos/artifact';
+import { type Message } from '@dxos/ai';
 import { createQueueDxn } from '@dxos/echo-schema';
 import { getSpace, useQueue } from '@dxos/react-client/echo';
 
@@ -13,9 +13,9 @@ import { type AIChatType } from '../types';
 export const useMessageQueue = (chat?: AIChatType) => {
   const space = getSpace(chat);
   const queueDxn = useMemo(() => {
-    const dxn = space && chat?.assistantChatQueue.dxn;
-    return dxn ? createQueueDxn(space.id) : undefined;
-  }, [space, chat?.assistantChatQueue.dxn]);
+    const dxn = space && chat?.queue.dxn;
+    return dxn ? createQueueDxn(space.id, dxn.parts.at(-1)) : undefined;
+  }, [space, chat?.queue.dxn]);
 
   return useQueue<Message>(queueDxn);
 };

package/src/meta.ts

@@ -13,6 +13,6 @@ export const meta: PluginMeta = {
   name: 'Assistant',
   description: 'The Assistant tab allows you to chat with your spaces inside of Composer.',
   icon: 'ph--atom--regular',
-  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/experimental/plugin-assistant',
-  tags: ['experimental'],
+  source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-assistant',
+  tags: ['labs'],
 };

package/src/parser/filter-generator.test.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { Filter } from '@dxos/echo-schema';
+
+import { createFilter } from './filter-generator';
+import { QueryParser } from './query-parser';
+
+describe('FilterGenerator', () => {
+  test('simple queries', ({ expect }) => {
+    const parser = new QueryParser('type:example.com/type/Person');
+    const ast = parser.parse();
+    expect(ast).toEqual({
+      type: 'binary',
+      operator: 'EQ',
+      left: {
+        type: 'identifier',
+        name: 'type',
+      },
+      right: {
+        type: 'literal',
+        value: 'example.com/type/Person',
+      },
+    });
+
+    const filter = createFilter(ast);
+    expect(filter).toEqual(Filter.typename('example.com/type/Person'));
+  });
+});

package/src/parser/filter-generator.ts

@@ -0,0 +1,81 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Filter } from '@dxos/echo-schema';
+
+import {
+  type BinaryExpression,
+  type Expression,
+  type Identifier,
+  type Literal,
+  type RelationalOperator,
+  type UnaryExpression,
+} from './types';
+
+const relationalOperators: Record<RelationalOperator, (value: any) => Filter<any>> = {
+  EQ: Filter.eq,
+  LT: Filter.lt,
+  GT: Filter.gt,
+};
+
+const specialPredicates: Record<string, (value: string) => Filter<any>> = {
+  ['type' as const]: Filter.typename,
+};
+
+export const createFilter = (ast: Expression): Filter<any> => {
+  switch (ast.type) {
+    case 'binary': {
+      const { operator, left, right } = ast as BinaryExpression;
+
+      // Handle logical operators.
+      if (operator === 'AND') {
+        return Filter.and(createFilter(left), createFilter(right));
+      }
+      if (operator === 'OR') {
+        return Filter.or(createFilter(left), createFilter(right));
+      }
+
+      // Handle special predicates (e.g., "type:Person")
+      const predicateName = (left as Identifier).name;
+      const specialFilter = specialPredicates[predicateName];
+      if (specialFilter) {
+        return specialFilter((right as Literal).value);
+      }
+
+      // Handle relational operators
+      const filterFn = relationalOperators[operator as RelationalOperator];
+      if (filterFn) {
+        return filterFn((right as Literal).value);
+      }
+
+      throw new Error(`Unsupported operator: ${operator}`);
+    }
+
+    case 'unary': {
+      const { operator, argument } = ast as UnaryExpression;
+      if (operator === 'NOT') {
+        return Filter.not(createFilter(argument));
+      }
+      throw new Error(`Unsupported unary operator: ${operator}`);
+    }
+
+    case 'identifier': {
+      const { name } = ast as Identifier;
+      return Filter._props({ [name]: true });
+    }
+
+    case 'literal': {
+      const { value } = ast as Literal;
+      // Handle special '*' value for empty input.
+      if (value === '*') {
+        return Filter.everything();
+      }
+
+      return Filter.eq(value);
+    }
+
+    default:
+      throw new Error(`Unsupported expression type: ${(ast as any).type}`);
+  }
+};

package/src/parser/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export * from './filter-generator';
+export * from './query-parser';
+export * from './types';

package/src/parser/query-parser.test.ts

@@ -0,0 +1,139 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { QueryParser } from './query-parser';
+
+describe('QueryParser', () => {
+  test('empty', ({ expect }) => {
+    const parser = new QueryParser('');
+    expect(parser.parse()).toEqual({
+      type: 'literal',
+      value: '*',
+    });
+  });
+
+  test('invalid queries', ({ expect }) => {
+    const cases = [
+      //
+      '!',
+      'X:',
+      ':Y',
+      'X;Y',
+      'x==100',
+    ];
+
+    for (const query of cases) {
+      const parser = new QueryParser(query);
+      expect(() => parser.parse()).toThrow();
+    }
+  });
+
+  test('valid queries', ({ expect }) => {
+    const cases = [
+      //
+      '',
+      'type:Person',
+      '$title = "foo"',
+      '(type:Person OR type:Organization) AND $title = "DXOS" AND $ts < TODAY',
+    ];
+
+    for (const query of cases) {
+      const parser = new QueryParser(query);
+      expect(parser.parse()).to.exist;
+    }
+  });
+
+  test('simple queries', ({ expect }) => {
+    const cases = [
+      {
+        query: 'type:Person',
+        ast: {
+          type: 'binary',
+          operator: 'EQ',
+          left: { type: 'identifier', name: 'type' },
+          right: { type: 'literal', value: 'Person' },
+        },
+      },
+      {
+        query: '$title = "DXOS"',
+        ast: {
+          type: 'binary',
+          operator: 'EQ',
+          left: { type: 'identifier', name: '$title' },
+          right: { type: 'literal', value: 'DXOS' },
+        },
+      },
+      {
+        query: '(type:Person OR type:Organization) AND $title = "DXOS" AND $ts < TODAY',
+        ast: {
+          left: {
+            left: {
+              left: {
+                left: {
+                  name: 'type',
+                  type: 'identifier',
+                },
+                operator: 'EQ',
+                right: {
+                  type: 'literal',
+                  value: 'Person',
+                },
+                type: 'binary',
+              },
+              operator: 'OR',
+              right: {
+                left: {
+                  name: 'type',
+                  type: 'identifier',
+                },
+                operator: 'EQ',
+                right: {
+                  type: 'literal',
+                  value: 'Organization',
+                },
+                type: 'binary',
+              },
+              type: 'binary',
+            },
+            operator: 'AND',
+            right: {
+              left: {
+                name: '$title',
+                type: 'identifier',
+              },
+              operator: 'EQ',
+              right: {
+                type: 'literal',
+                value: 'DXOS',
+              },
+              type: 'binary',
+            },
+            type: 'binary',
+          },
+          operator: 'AND',
+          right: {
+            left: {
+              name: '$ts',
+              type: 'identifier',
+            },
+            operator: 'LT',
+            right: {
+              type: 'literal',
+              value: 'TODAY',
+            },
+            type: 'binary',
+          },
+          type: 'binary',
+        },
+      },
+    ];
+
+    for (const { query, ast } of cases) {
+      const parser = new QueryParser(query);
+      expect(parser.parse()).toEqual(ast);
+    }
+  });
+});

package/src/parser/query-parser.ts

@@ -0,0 +1,199 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { invariant } from '@dxos/invariant';
+
+import { type Expression, type BinaryOperator, type RelationalOperator } from './types';
+
+// TODO(burdon): Move to echo-schema?
+
+type RelationalSymbol = '=' | '<' | '>';
+
+const operators: Record<RelationalSymbol, RelationalOperator> = {
+  '=': 'EQ',
+  '<': 'LT',
+  '>': 'GT',
+};
+
+export class QueryParser {
+  private tokens: string[] = [];
+  private current = 0;
+
+  constructor(input: string) {
+    // Tokenize the input string.
+    this.tokens = this.tokenize(input);
+  }
+
+  private tokenize(input: string): string[] {
+    // Handle empty input.
+    if (!input.trim()) {
+      return [];
+    }
+
+    // Split on spaces but preserve quoted strings.
+    const tokens: string[] = [];
+    let current = '';
+    let inQuotes = false;
+
+    for (let i = 0; i < input.length; i++) {
+      const char = input[i];
+
+      if (char === '"') {
+        // Handle quoted strings.
+        inQuotes = !inQuotes;
+        current += char;
+      } else if (char === '(' || char === ')') {
+        // If we have accumulated tokens, add them first.
+        if (current) {
+          tokens.push(current);
+          current = '';
+        }
+        // Add the parenthesis as a separate token.
+        tokens.push(char);
+      } else if (operators[char as RelationalSymbol]) {
+        // If we have accumulated tokens, add them first.
+        if (current) {
+          tokens.push(current);
+          current = '';
+        }
+        // Add the operator as a separate token.
+        tokens.push(operators[char as RelationalSymbol]);
+      } else if (char === ' ' && !inQuotes) {
+        if (current) {
+          tokens.push(current);
+          current = '';
+        }
+      } else {
+        current += char;
+      }
+    }
+
+    if (current) {
+      tokens.push(current);
+    }
+
+    return tokens;
+  }
+
+  private peek(): string {
+    return this.tokens[this.current];
+  }
+
+  private advance(): string {
+    return this.tokens[this.current++];
+  }
+
+  private match(type: string): boolean {
+    if (this.peek() === type) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+
+  private isAtEnd(): boolean {
+    return this.current >= this.tokens.length;
+  }
+
+  private parseExpression(): Expression {
+    let expr = this.parseTerm();
+
+    while (!this.isAtEnd()) {
+      const operator = this.peek();
+      if (operator === 'AND' || operator === 'OR') {
+        this.advance();
+        const right = this.parseTerm();
+        expr = {
+          type: 'binary',
+          operator: operator as BinaryOperator,
+          left: expr,
+          right,
+        };
+      } else {
+        break;
+      }
+    }
+
+    return expr;
+  }
+
+  private parseTerm(): Expression {
+    // Handle NOT operator
+    if (this.peek() === 'NOT') {
+      this.advance();
+      const argument = this.parseTerm();
+      return {
+        type: 'unary',
+        operator: 'NOT',
+        argument,
+      };
+    }
+
+    // Handle parentheses.
+    if (this.match('(')) {
+      const expr = this.parseExpression();
+      if (!this.match(')')) {
+        throw new Error('Expected closing parenthesis');
+      }
+      return expr;
+    }
+
+    const token = this.peek();
+
+    // Handle type:Person style expressions.
+    if (token.includes(':')) {
+      const [field, value] = token.split(':');
+      this.advance();
+      if (!field || !value) {
+        throw new Error(`Invalid type expression: ${token}`);
+      }
+
+      return {
+        type: 'binary',
+        operator: 'EQ',
+        left: { type: 'identifier', name: field },
+        right: { type: 'literal', value },
+      };
+    }
+
+    // Handle $field expressions with operators.
+    if (token.startsWith('$')) {
+      const field = token;
+      this.advance();
+
+      // Get the operator.
+      const operator = this.peek();
+      if (operator !== 'EQ' && operator !== 'LT' && operator !== 'GT') {
+        throw new Error(`Expected operator after field ${field}, got ${operator}`);
+      }
+      this.advance();
+
+      // Get the value
+      const value = this.peek();
+      this.advance();
+      invariant(value);
+
+      return {
+        type: 'binary',
+        operator: operator as BinaryOperator,
+        left: { type: 'identifier', name: field },
+        right: { type: 'literal', value: value.replace(/^"|"$/g, '') },
+      };
+    }
+
+    throw new Error(`Unexpected token: ${token}`);
+  }
+
+  public parse(): Expression {
+    // Return a special expression for empty input.
+    if (this.tokens.length === 0) {
+      return {
+        type: 'literal',
+        value: '*',
+      };
+    }
+
+    return this.parseExpression();
+  }
+}

package/src/parser/types.ts

@@ -0,0 +1,34 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export type UnaryOperator = 'NOT';
+
+export type RelationalOperator = 'EQ' | 'LT' | 'GT';
+
+export type BinaryOperator = RelationalOperator | 'AND' | 'OR';
+
+export type Expression = BinaryExpression | UnaryExpression | Identifier | Literal;
+
+export interface BinaryExpression {
+  type: 'binary';
+  operator: BinaryOperator;
+  left: Expression;
+  right: Expression;
+}
+
+export interface UnaryExpression {
+  type: 'unary';
+  operator: UnaryOperator;
+  argument: Expression;
+}
+
+export interface Identifier {
+  type: 'identifier';
+  name: string;
+}
+
+export interface Literal {
+  type: 'literal';
+  value: string;
+}

package/src/shims.d.ts

@@ -0,0 +1,8 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+declare module '*?raw' {
+  const content: string;
+  export default content;
+}

package/src/stories/Prompt.stories.tsx

@@ -0,0 +1,59 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import '@dxos-theme';
+
+import { type Meta, type StoryObj } from '@storybook/react';
+import React, { useCallback, useState } from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { JsonFilter } from '@dxos/react-ui-syntax-highlighter';
+import { withLayout, withTheme } from '@dxos/storybook-utils';
+
+import { PromptBar, type PromptBarProps } from '../components';
+import { type Expression, QueryParser } from '../parser';
+import translations from '../translations';
+
+const DefaultStory = (props: PromptBarProps) => {
+  const [ast, setAst] = useState<Expression>();
+  const handleSubmit = useCallback<NonNullable<PromptBarProps['onSubmit']>>((text) => {
+    const parser = new QueryParser(text);
+    const ast = parser.parse();
+    setAst(ast);
+  }, []);
+
+  return (
+    <div className='flex flex-col w-[40rem] border border-separator rounded-md'>
+      <PromptBar {...props} onSubmit={handleSubmit} />
+      <JsonFilter data={{ ast }} />
+    </div>
+  );
+};
+
+const meta: Meta<typeof PromptBar> = {
+  title: 'plugins/plugin-assistant/QueryPrompt',
+  render: DefaultStory,
+  decorators: [
+    withPluginManager({
+      plugins: [],
+    }),
+    withTheme,
+    withLayout({
+      fullscreen: true,
+      classNames: 'justify-center',
+    }),
+  ],
+  parameters: {
+    translations,
+    layout: 'centered',
+  },
+};
+
+type Story = StoryObj<typeof PromptBar>;
+
+export default meta;
+
+export const Default: Story = {
+  args: {},
+};