@dxos/plugin-assistant 0.8.4-main.28f8d3d → 0.8.4-main.406dc2a

package/src/components/ChatThread/reducer.ts

@@ -1,52 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { type DataType } from '@dxos/schema';
-
-// TODO(burdon): Move to util?
-type Reducer<R, I> = (acc: R, value: I) => R;
-
-/**
- * Reducer that collapses related message blocks into single messages.
- * For example, combines tool request/response pairs into a single message.
- */
-export const messageReducer: Reducer<{ messages: DataType.Message[]; current?: DataType.Message }, DataType.Message> = (
-  { current, messages },
-  message,
-) => {
-  let i = 0;
-  for (const block of message.blocks) {
-    switch (block._tag) {
-      case 'toolCall':
-      case 'toolResult': {
-        if (current) {
-          current.blocks.push(block);
-        } else {
-          current = {
-            ...message,
-            id: [message.id, i].join('_'),
-            blocks: [block],
-          };
-          messages.push(current);
-        }
-        break;
-      }
-
-      case 'text':
-      default: {
-        current = undefined;
-        messages.push({
-          ...message,
-          id: [message.id, i].join('_'),
-          blocks: [block],
-        });
-        break;
-      }
-    }
-
-    i++;
-  }
-
-  return { current, messages };
-};

package/src/components/Timeline/Timeline.stories.tsx

@@ -1,53 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import '@dxos-theme';
-
-import { type Meta, type StoryObj } from '@storybook/react-vite';
-
-import { faker } from '@dxos/random';
-import { withTheme } from '@dxos/storybook-utils';
-
-import { Timeline } from './Timeline';
-
-faker.seed(1);
-
-const meta: Meta<typeof Timeline> = {
-  title: 'plugins/plugin-assistant/Timeline',
-  component: Timeline,
-  decorators: [withTheme],
-};
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-export const Default: Story = {
-  args: {
-    branches: [{ name: 'main' }, { name: 'feature-a' }, { name: 'feature-b' }, { name: 'feature-c' }],
-    commits: [
-      { id: 'c1', message: faker.lorem.paragraph(), branch: 'main' },
-      { id: 'c2', message: faker.lorem.paragraph(), branch: 'main', parent: 'c1' },
-      { id: 'c3', message: faker.lorem.paragraph(), branch: 'feature-a', parent: 'c2' },
-      { id: 'c4', message: faker.lorem.paragraph(), branch: 'main', parent: 'c2' },
-      { id: 'c5', message: faker.lorem.paragraph(), branch: 'feature-b', parent: 'c2' },
-      { id: 'c6', message: faker.lorem.paragraph(), branch: 'feature-a', parent: 'c3' },
-      { id: 'c7', message: faker.lorem.paragraph(), branch: 'feature-a', parent: 'c6' },
-      { id: 'c8', message: faker.lorem.paragraph(), branch: 'feature-c', parent: 'c6' },
-      { id: 'c9', message: faker.lorem.paragraph(), branch: 'main', parent: 'c4' },
-    ],
-  },
-};
-
-export const Linear: Story = {
-  args: {
-    branches: [{ name: 'main' }],
-    commits: [
-      { id: 'c1', message: faker.lorem.paragraph(), branch: 'main' },
-      { id: 'c2', message: faker.lorem.paragraph(), branch: 'main', parent: 'c1' },
-      { id: 'c3', message: faker.lorem.paragraph(), branch: 'main', parent: 'c2' },
-      { id: 'c4', message: faker.lorem.paragraph(), branch: 'main', parent: 'c3' },
-    ],
-  },
-};

package/src/components/Timeline/Timeline.tsx

@@ -1,159 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import React, { Fragment, useMemo } from 'react';
-
-import { type ThemedClassName } from '@dxos/react-ui';
-import { mx } from '@dxos/react-ui-theme';
-import { trim } from '@dxos/util';
-
-export type Commit = {
-  id: string;
-  parent?: string;
-  branch: string;
-  message: string;
-  timestamp?: Date;
-  tags?: string[];
-};
-
-export type Branch = {
-  name: string;
-};
-
-export type Span = {
-  start: number;
-  end: number;
-  parent?: number;
-};
-
-export type TimelineProps = ThemedClassName<{ branches: Branch[]; commits: Commit[] }>;
-
-// TODO(burdon): Reuse in toolCall messages.
-// TODO(burdon): Key up/down; selected.
-export const Timeline = ({ classNames, branches, commits }: TimelineProps) => {
-  const spans = useMemo(() => {
-    const spans = new Map<string, Span>();
-    branches.forEach((branch) => {
-      spans.set(branch.name, { start: -1, end: -1 });
-    });
-
-    commits.forEach((commit, index) => {
-      const span = spans.get(commit.branch);
-      if (span) {
-        if (span.start === -1) {
-          const parentIndex = commit.parent ? commits.findIndex((c) => c.id === commit.parent) : 0;
-          span.start = parentIndex;
-          span.parent = commit.parent
-            ? branches.findIndex((branch) => branch.name === commits[parentIndex].branch)
-            : undefined;
-        }
-        span.end = index;
-      }
-    });
-
-    return spans;
-  }, [commits, branches]);
-
-  return (
-    <div className={mx('flex flex-col w-full overflow-hidden', classNames)}>
-      {commits.map((commit, index) => {
-        return (
-          <div
-            key={commit.id}
-            className='group flex items-center gap-2 overflow-hidden hover:bg-hoverSurface'
-            style={{ height: `${lineHeight}px` }}
-          >
-            <svg width={branches.length * columnWidth} height={lineHeight} className='shrink-0'>
-              {branches.map((branch, j) => {
-                const span = spans.get(branch.name);
-                const color = colors[j % colors.length];
-                if (!span) {
-                  return null;
-                }
-
-                return (
-                  <Fragment key={j}>
-                    {/* Upper */}
-                    {index !== 0 && span.start !== -1 && span.start < index && span.end >= index && (
-                      <line
-                        x1={j * columnWidth + columnWidth / 2}
-                        y1={0}
-                        x2={j * columnWidth + columnWidth / 2}
-                        y2={lineHeight / 2}
-                        className={mx('stroke-2', color.stroke)}
-                      />
-                    )}
-                    {/* Lower */}
-                    {span.end !== -1 && (span.start < index || span.start === 0) && index < span.end && (
-                      <line
-                        x1={j * columnWidth + columnWidth / 2}
-                        y1={lineHeight / 2}
-                        x2={j * columnWidth + columnWidth / 2}
-                        y2={lineHeight}
-                        className={mx('stroke-2', color.stroke)}
-                      />
-                    )}
-                    {/* Arc to parent */}
-                    {span.start === index && span.parent !== undefined && span.parent !== -1 && (
-                      <path
-                        d={trim`
-                          M ${0.5 + span.parent * columnWidth + columnWidth / 2} ${lineHeight / 2} 
-                          L ${j * columnWidth + columnWidth / 4} ${lineHeight / 2} 
-                          A ${lineHeight / 4} ${lineHeight / 4} 0 0 1 ${j * columnWidth + columnWidth / 2} ${(lineHeight * 3) / 4} 
-                          L ${j * columnWidth + columnWidth / 2} ${lineHeight}
-                        `}
-                        className={mx('stroke-2', color.stroke)}
-                        fill='none'
-                      />
-                    )}
-                    {branch.name === commit.branch && (
-                      <circle
-                        cx={j * columnWidth + columnWidth / 2}
-                        cy={lineHeight / 2}
-                        r={nodeRadius}
-                        className={mx('stroke-2 fill-red-500', color.stroke, color.hover)}
-                      />
-                    )}
-                  </Fragment>
-                );
-              })}
-              {branches.map((branch, j) => {
-                const color = colors[j % colors.length];
-                return (
-                  branch.name === commit.branch && (
-                    <circle
-                      key={j}
-                      cx={j * columnWidth + columnWidth / 2}
-                      cy={lineHeight / 2}
-                      r={nodeRadius}
-                      className={mx('stroke-2', color.stroke, color.hover)}
-                    />
-                  )
-                );
-              })}
-            </svg>
-            <div className='text-sm truncate cursor-pointer text-subdued group-hover:text-baseText'>
-              {commit.message}
-            </div>
-          </div>
-        );
-      })}
-    </div>
-  );
-};
-
-const lineHeight = 24;
-const columnWidth = 24;
-const nodeRadius = 6;
-
-const colors = [
-  { stroke: 'stroke-orange-500', hover: 'group-hover:fill-orange-500' },
-  { stroke: 'stroke-sky-500', hover: 'group-hover:fill-sky-500' },
-  { stroke: 'stroke-green-500', hover: 'group-hover:fill-green-500' },
-  { stroke: 'stroke-fuchsia-500', hover: 'group-hover:fill-fuchsia-500' },
-  { stroke: 'stroke-cyan-500', hover: 'group-hover:fill-cyan-500' },
-  { stroke: 'stroke-emerald-500', hover: 'group-hover:fill-emerald-500' },
-  { stroke: 'stroke-violet-500', hover: 'group-hover:fill-violet-500' },
-  { stroke: 'stroke-teal-500', hover: 'group-hover:fill-teal-500' },
-];

package/src/hooks/chat-processor.ts

@@ -1,260 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Registry, Result, Rx } from '@effect-rx/rx-react';
-import { Effect, type Layer, Option, Stream, pipe } from 'effect';
-
-import { AiService, DEFAULT_EDGE_MODEL, type ModelName, type ModelRegistry } from '@dxos/ai';
-import { type PromiseIntentDispatcher } from '@dxos/app-framework';
-import {
-  type AiConversation,
-  type AiConversationRunParams,
-  AiSession,
-  ArtifactDiffResolver,
-  createSystemPrompt,
-} from '@dxos/assistant';
-import { type Blueprint } from '@dxos/blueprints';
-import { Context } from '@dxos/context';
-import { Obj } from '@dxos/echo';
-import { runAndForwardErrors } from '@dxos/effect';
-import { log } from '@dxos/log';
-import { Filter, type Space, getVersion } from '@dxos/react-client/echo';
-import { type ContentBlock, DataType } from '@dxos/schema';
-
-import { AiServiceOverloadedError } from './errors';
-import { type AiChatServices } from './useChatServices';
-
-// TODO(burdon): Is this still used?
-declare global {
-  interface ToolContextExtensions {
-    space?: Space;
-    dispatch?: PromiseIntentDispatcher;
-  }
-}
-
-export type AiRequestOptions = {
-  // Empty for now.
-};
-
-export type AiChatProcessorOptions = {
-  model?: ModelName;
-  modelRegistry?: ModelRegistry;
-  blueprintRegistry?: Blueprint.Registry;
-  observableRegistry?: Registry.Registry;
-  extensions?: ToolContextExtensions;
-} & Pick<AiConversationRunParams<any>, 'system'>;
-
-const defaultOptions: Partial<AiChatProcessorOptions> = {
-  model: DEFAULT_EDGE_MODEL,
-};
-
-/**
- * Handles interactions with the AI service.
- * Maintains a queue of messages and handles streaming responses from the AI service.
- * Executes tools based on AI responses.
- * Supports cancellation of in-progress requests.
- */
-export class AiChatProcessor {
-  /**
-   * Last error.
-   */
-  // TODO(wittjosiah): Error should come from the message stream.
-  readonly error = Rx.make<Option.Option<Error>>(Option.none());
-
-  /** Rx registry. */
-  private readonly _observableRegistry: Registry.Registry;
-
-  /** Current session. */
-  private readonly _session = Rx.make<Option.Option<AiSession>>(Option.none());
-
-  /**
-   * Current streaming message (from the AI service).
-   */
-  private readonly _streaming: Rx.Rx<Result.Result<Option.Option<DataType.Message>, Error>> = Rx.make((get) => {
-    return pipe(
-      get(this._session),
-      Option.map((session) => Stream.fromQueue(session.blockQueue)),
-      Option.getOrElse(() => Stream.make()),
-      Stream.scan<Option.Option<DataType.Message>, Option.Option<ContentBlock.Any>>(Option.none(), (acc, blockOption) =>
-        Option.flatMap(blockOption, (block) =>
-          acc.pipe(
-            Option.match({
-              onNone: () => [block],
-              onSome: (message) => [...message.blocks.filter((b) => !b.pending), block],
-            }),
-            Option.some,
-            Option.map((blocks) =>
-              Obj.make(DataType.Message, {
-                created: new Date().toISOString(),
-                sender: { role: 'assistant' },
-                blocks,
-              }),
-            ),
-          ),
-        ),
-      ),
-    );
-  });
-
-  /**
-   * Streaming state.
-   */
-  readonly streaming: Rx.Rx<boolean> = Rx.make((get) => {
-    return pipe(
-      get(this._streaming),
-      Result.map((streaming) => Option.isSome(streaming)),
-      Result.getOrElse(() => false),
-    );
-  });
-
-  /**
-   * Pending messages (incl. the current user request).
-   */
-  private readonly _pending: Rx.Rx<Result.Result<DataType.Message[], Error>> = Rx.make((get) => {
-    // TODO(wittjosiah): For some reason using Option.map here loses reactivity.
-    const session = get(this._session);
-    return Option.isSome(session)
-      ? pipe(
-          session.value.messageQueue,
-          Stream.fromQueue,
-          Stream.scan<DataType.Message[], DataType.Message>([], (acc, message) => [...acc, message]),
-        )
-      : Stream.make();
-  });
-
-  /**
-   * Array of Messages (incl. the current message being streamed).
-   */
-  readonly messages: Rx.Rx<Result.Result<DataType.Message[], Error>> = Rx.make((get) => {
-    const streaming = get(this._streaming);
-    return Result.map(get(this._pending), (pending) =>
-      Result.match(streaming, {
-        onInitial: () => pending,
-        onSuccess: (streaming) =>
-          Option.match(streaming.value, {
-            onNone: () => pending,
-            onSome: (message) => [...pending, message],
-          }),
-        onFailure: () => pending,
-      }),
-    );
-  });
-
-  constructor(
-    // TODO(dmaretskyi): Replace this with effect's ManagedRuntime wrapping this layer.
-    private readonly _services: Layer.Layer<AiChatServices>,
-    private readonly _conversation: AiConversation,
-    private readonly _options: AiChatProcessorOptions = defaultOptions,
-  ) {
-    // Initialize registries and defaults before using in other logic.
-    this._observableRegistry = this._options.observableRegistry ?? Registry.make();
-    if (this._options.model && !this._options.system) {
-      const capabilities = this._options.modelRegistry?.getCapabilities(this._options.model) ?? {};
-      this._options.system = createSystemPrompt(capabilities);
-    }
-  }
-
-  get context() {
-    return this._conversation.context;
-  }
-
-  get conversation() {
-    return this._conversation;
-  }
-
-  get blueprintRegistry() {
-    return this._options.blueprintRegistry;
-  }
-
-  /**
-   * Make GPT request.
-   */
-  async request(message: string, _options: AiRequestOptions = {}): Promise<void> {
-    await using ctx = Context.default(); // Auto-disposed at the end of this block.
-
-    const session = new AiSession();
-    this._observableRegistry.set(this._session, Option.some(session));
-
-    ctx.onDispose(() => {
-      log.info('onDispose', { session, isDisposed: ctx.disposed });
-      Option.match(this._observableRegistry.get(this._session), {
-        onSome: (s) => {
-          if (s === session) {
-            this._observableRegistry.set(this._session, Option.none());
-          }
-        },
-        onNone: () => {},
-      });
-    });
-
-    try {
-      const messages = await runAndForwardErrors(
-        this._conversation
-          .run({
-            session,
-            prompt: message,
-            system: this._options.system,
-          })
-          .pipe(
-            Effect.provide(AiService.model(this._options.model ?? DEFAULT_EDGE_MODEL)),
-            // TODO(dmaretskyi): Move ArtifactDiffResolver upstream.
-            Effect.provideService(ArtifactDiffResolver, this._artifactDiffResolver),
-            Effect.provide(this._services),
-            Effect.tapErrorCause((cause) => {
-              log.error('error', { cause });
-              return Effect.void;
-            }),
-          ),
-      );
-
-      log('completed', { messages });
-    } catch (err) {
-      log.catch(err);
-      if (err instanceof Error && err.message.includes('Overloaded')) {
-        this._observableRegistry.set(
-          this.error,
-          Option.some(new AiServiceOverloadedError('AI service overloaded', { cause: err })),
-        );
-      } else {
-        this._observableRegistry.set(this.error, Option.some(new Error('AI service error', { cause: err })));
-      }
-    }
-  }
-
-  /**
-   * Cancel pending requests.
-   */
-  async cancel(): Promise<void> {
-    log.info('cancelling...');
-
-    // TODO(dmaretskyi): Abort using Fiber.interrupt.
-  }
-
-  private _artifactDiffResolver: ArtifactDiffResolver.Service = {
-    resolve: async (artifacts) => {
-      const space = this._options.extensions?.space;
-      if (!space) {
-        return new Map();
-      }
-
-      const versions = new Map();
-      await Promise.all(
-        artifacts.map(async (artifact) => {
-          const {
-            objects: [object],
-          } = await space.db.query(Filter.ids(artifact.id)).run();
-          if (!object) {
-            return;
-          }
-
-          versions.set(artifact.id, {
-            version: getVersion(object),
-            diff: `Current state: ${JSON.stringify(object)}`,
-          });
-        }),
-      );
-      return versions;
-    },
-  };
-}

package/src/hooks/errors.ts

@@ -1,8 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-// TODO(wittjosiah): Move to ai-service-client.
-export class AiServiceOverloadedError extends Error {
-  code = 'AI_SERVICE_OVERLOADED';
-}

package/src/hooks/useResolveRef.ts

@@ -1,33 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { useMemo, useSyncExternalStore } from 'react';
-
-import { type Space } from '@dxos/client/echo';
-import { type Ref } from '@dxos/echo';
-
-// TODO(burdon): Factor out.
-export const useResolvedRef = <T>(space: Space, ref: Ref.Ref<T>): T | undefined => {
-  const { subscribe, getSnapshot } = useMemo(() => {
-    const resolver = space.db.graph.createRefResolver({});
-    let currentCallback: (() => void) | undefined = undefined;
-
-    return {
-      subscribe: (cb: () => void) => {
-        currentCallback = cb;
-        return () => {
-          if (currentCallback === cb) {
-            currentCallback = undefined;
-          }
-        };
-      },
-      getSnapshot: () =>
-        resolver?.resolveSync(ref.dxn, true, () => {
-          currentCallback?.();
-        }) as T | undefined,
-    };
-  }, [space, ref.dxn.toString()]);
-
-  return useSyncExternalStore<T | undefined>(subscribe, getSnapshot);
-};

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

@@ -1,32 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { describe, test } from 'vitest';
-
-import { Filter } from '@dxos/echo';
-
-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

@@ -1,74 +0,0 @@
-//
-// Copyright 2025 DXOS.org
-//
-
-import { Filter } from '@dxos/echo';
-
-import { type Expression, type Identifier, type Literal, type RelationalOperator } 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;
-
-      // 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];
-      if (filterFn) {
-        return filterFn((right as Literal).value);
-      }
-
-      throw new Error(`Unsupported operator: ${operator}`);
-    }
-
-    case 'unary': {
-      const { operator, argument } = ast;
-      if (operator === 'NOT') {
-        return Filter.not(createFilter(argument));
-      }
-      throw new Error(`Unsupported unary operator: ${operator}`);
-    }
-
-    case 'identifier': {
-      const { name } = ast;
-      return Filter._props({ [name]: true });
-    }
-
-    case 'literal': {
-      const { value } = ast;
-      // 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

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