@dxos/plugin-assistant 0.8.2-staging.7ac8446 → 0.8.3-main.672df60

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,60 @@
+//
+// 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',
+    controls: { disable: true },
+  },
+};
+
+type Story = StoryObj<typeof PromptBar>;
+
+export default meta;
+
+export const Default: Story = {
+  args: {},
+};