@dxos/assistant 0.8.4-main.b97322e → 0.8.4-main.bc674ce

package/package.json

@@ -1,70 +1,93 @@
 {
   "name": "@dxos/assistant",
-  "version": "0.8.4-main.b97322e",
+  "version": "0.8.4-main.bc674ce",
   "description": "Natural language interface to DXOS",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dxos/dxos"
+  },
   "license": "MIT",
   "author": "info@dxos.org",
   "sideEffects": true,
   "type": "module",
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "types": "./dist/types/src/index.d.ts",
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node-esm/index.mjs"
+    },
+    "./extraction": {
+      "source": "./src/extraction/index.ts",
+      "types": "./dist/types/src/extraction/index.d.ts",
+      "browser": "./dist/lib/browser/extraction/index.mjs",
+      "node": "./dist/lib/node-esm/extraction/index.mjs"
+    },
+    "./testing": {
+      "source": "./src/testing/index.ts",
+      "types": "./dist/types/src/testing/index.d.ts",
+      "browser": "./dist/lib/browser/testing/index.mjs",
+      "node": "./dist/lib/node-esm/testing/index.mjs"
     }
   },
   "types": "dist/types/src/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "types": [
+        "dist/types/src/types/index.d.ts"
+      ],
+      "extraction": [
+        "dist/types/src/extraction/index.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist",
     "src"
   ],
   "dependencies": {
-    "@effect/ai": "0.23.0",
-    "@effect/ai-anthropic": "^0.13.0",
-    "@effect/platform": "^0.89.0",
-    "@effect/platform-node": "^0.92.0",
-    "@preact/signals-core": "^1.9.0",
+    "@automerge/automerge": "3.2.3",
+    "@effect-atom/atom-react": "^0.4.6",
+    "@effect/ai": "0.32.1",
+    "@effect/experimental": "0.57.11",
+    "@effect/platform": "0.93.6",
     "@xenova/transformers": "^2.17.2",
-    "chalk": "^4.1.0",
-    "exa-js": "^1.5.12",
-    "handlebars": "4.7.8",
     "lodash.defaultsdeep": "^4.6.1",
-    "@dxos/ai": "0.8.4-main.b97322e",
-    "@dxos/async": "0.8.4-main.b97322e",
-    "@dxos/context": "0.8.4-main.b97322e",
-    "@dxos/blueprints": "0.8.4-main.b97322e",
-    "@dxos/debug": "0.8.4-main.b97322e",
-    "@dxos/echo": "0.8.4-main.b97322e",
-    "@dxos/echo-db": "0.8.4-main.b97322e",
-    "@dxos/effect": "0.8.4-main.b97322e",
-    "@dxos/echo-schema": "0.8.4-main.b97322e",
-    "@dxos/errors": "0.8.4-main.b97322e",
-    "@dxos/functions": "0.8.4-main.b97322e",
-    "@dxos/invariant": "0.8.4-main.b97322e",
-    "@dxos/graph": "0.8.4-main.b97322e",
-    "@dxos/keys": "0.8.4-main.b97322e",
-    "@dxos/log": "0.8.4-main.b97322e",
-    "@dxos/live-object": "0.8.4-main.b97322e",
-    "@dxos/node-std": "0.8.4-main.b97322e",
-    "@dxos/schema": "0.8.4-main.b97322e",
-    "@dxos/util": "0.8.4-main.b97322e",
-    "@dxos/echo-protocol": "0.8.4-main.b97322e"
+    "@dxos/ai": "0.8.4-main.bc674ce",
+    "@dxos/blueprints": "0.8.4-main.bc674ce",
+    "@dxos/context": "0.8.4-main.bc674ce",
+    "@dxos/async": "0.8.4-main.bc674ce",
+    "@dxos/echo": "0.8.4-main.bc674ce",
+    "@dxos/debug": "0.8.4-main.bc674ce",
+    "@dxos/echo-db": "0.8.4-main.bc674ce",
+    "@dxos/echo-protocol": "0.8.4-main.bc674ce",
+    "@dxos/effect": "0.8.4-main.bc674ce",
+    "@dxos/functions": "0.8.4-main.bc674ce",
+    "@dxos/errors": "0.8.4-main.bc674ce",
+    "@dxos/functions-runtime": "0.8.4-main.bc674ce",
+    "@dxos/graph": "0.8.4-main.bc674ce",
+    "@dxos/invariant": "0.8.4-main.bc674ce",
+    "@dxos/keys": "0.8.4-main.bc674ce",
+    "@dxos/log": "0.8.4-main.bc674ce",
+    "@dxos/schema": "0.8.4-main.bc674ce",
+    "@dxos/node-std": "0.8.4-main.bc674ce",
+    "@dxos/types": "0.8.4-main.bc674ce",
+    "@dxos/util": "0.8.4-main.bc674ce"
   },
   "devDependencies": {
     "@types/lodash.defaultsdeep": "^4.6.6",
-    "effect": "3.17.0",
-    "inquirer": "^12.0.0"
+    "effect": "3.19.11"
   },
   "peerDependencies": {
-    "effect": "^3.13.3"
+    "effect": "3.19.11"
   },
   "publishConfig": {
     "access": "public"
   },
   "beast": {},
   "scripts": {
-    "run:chat": "tsx ./bin/chat.ts"
+    "run:chat": "vite-node ./bin/chat.ts"
   }
 }

package/src/conversation/context.test.ts

@@ -0,0 +1,46 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, it } from 'vitest';
+
+import { Obj, Ref, Type } from '@dxos/echo';
+import { type Queue } from '@dxos/echo-db';
+
+import { AiContextBinder } from './context';
+
+// TODO(burdon): Create mock queue?
+const createMockQueue = (): Queue =>
+  ({
+    query: () =>
+      ({
+        subscribe: () => ({ unsubscribe: () => {} }),
+        results: [],
+      }) as any,
+    append: async () => {
+      return [] as any;
+    },
+  }) as any;
+
+describe('AiContextBinder', () => {
+  it('should handle bind with Ref', async () => {
+    const queue = createMockQueue();
+    const binder = new AiContextBinder({ queue });
+
+    const TestSchema = Schema.Struct({}).pipe(
+      Type.object({
+        typename: 'dxos.org/type/Example',
+        version: '0.1.0',
+      }),
+    );
+
+    const obj = Obj.make(TestSchema, {});
+    const ref = Ref.make(obj);
+
+    await binder.bind({
+      blueprints: [],
+      objects: [ref],
+    });
+  });
+});

package/src/conversation/context.ts

@@ -0,0 +1,303 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom, Registry } from '@effect-atom/atom-react';
+import * as EArray from 'effect/Array';
+import * as Context from 'effect/Context';
+import * as Function from 'effect/Function';
+import * as Schema from 'effect/Schema';
+
+import { Blueprint } from '@dxos/blueprints';
+import { Resource } from '@dxos/context';
+import { DXN, Obj, Query, type Ref, Type } from '@dxos/echo';
+import { type Queue } from '@dxos/echo-db';
+import { log } from '@dxos/log';
+import { ComplexSet, isTruthy } from '@dxos/util';
+
+/**
+ * Thread message that binds or unbinds contextual objects to a conversation.
+ */
+// TODO(burdon): Move to @dxos/schema ContentBlock?
+export const ContextBinding = Schema.Struct({
+  blueprints: Schema.Struct({
+    added: Schema.Array(Type.Ref(Blueprint.Blueprint)),
+    removed: Schema.Array(Type.Ref(Blueprint.Blueprint)),
+  }),
+
+  objects: Schema.Struct({
+    added: Schema.Array(Type.Ref(Type.Obj)),
+    removed: Schema.Array(Type.Ref(Type.Obj)),
+  }),
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/ContextBinding',
+    version: '0.1.0',
+  }),
+);
+
+export interface ContextBinding extends Schema.Schema.Type<typeof ContextBinding> {}
+
+export type BindingProps = Partial<{
+  blueprints: Ref.Ref<Blueprint.Blueprint>[];
+  objects: Ref.Ref<Obj.Unknown>[];
+}>;
+
+export class Bindings {
+  readonly blueprints = new ComplexSet<Ref.Ref<Blueprint.Blueprint>>((ref) => ref.dxn.toString());
+
+  // TODO(burdon): Some DXNs have the Space prefix so only compare the object ID.
+  readonly objects = new ComplexSet<Ref.Ref<Obj.Unknown>>((ref) => ref.dxn.asEchoDXN()?.echoId);
+
+  toJSON() {
+    return {
+      blueprints: EArray.fromIterable(this.blueprints).map((ref) => ref.dxn.toString()),
+      objects: EArray.fromIterable(this.objects).map((ref) => ref.dxn.toString()),
+    };
+  }
+}
+
+export type AiContextBinderOptions = {
+  queue: Queue;
+  registry?: Registry.Registry;
+};
+
+/**
+ * Manages bindings of blueprints and objects to a conversation.
+ */
+// TODO(burdon): Context should manage ephemeral state of bindings until prompt is issued?
+export class AiContextBinder extends Resource {
+  private readonly _blueprints = Atom.make<Blueprint.Blueprint[]>([]).pipe(Atom.keepAlive);
+  private readonly _objects = Atom.make<Obj.Unknown[]>([]).pipe(Atom.keepAlive);
+  private readonly _registry: Registry.Registry;
+  private readonly _queue: Queue;
+
+  constructor(options: AiContextBinderOptions) {
+    super();
+    this._queue = options.queue;
+    this._registry = options.registry ?? Registry.make();
+  }
+
+  /**
+   * Returns the blueprints atom for subscription.
+   */
+  get blueprints(): Atom.Atom<Blueprint.Blueprint[]> {
+    return this._blueprints;
+  }
+
+  /**
+   * Returns the objects atom for subscription.
+   */
+  get objects(): Atom.Atom<Obj.Unknown[]> {
+    return this._objects;
+  }
+
+  /**
+   * Gets the current blueprints value.
+   */
+  getBlueprints(): Blueprint.Blueprint[] {
+    return this._registry.get(this._blueprints);
+  }
+
+  /**
+   * Gets the current objects value.
+   */
+  getObjects(): Obj.Unknown[] {
+    return this._registry.get(this._objects);
+  }
+
+  /**
+   * Subscribe to changes in blueprints.
+   */
+  subscribeBlueprints(cb: (blueprints: Blueprint.Blueprint[]) => void): () => void {
+    return this._registry.subscribe(this._blueprints, () => cb(this._registry.get(this._blueprints)));
+  }
+
+  /**
+   * Subscribe to changes in objects.
+   */
+  subscribeObjects(cb: (objects: Obj.Unknown[]) => void): () => void {
+    return this._registry.subscribe(this._objects, () => cb(this._registry.get(this._objects)));
+  }
+
+  protected override async _open(): Promise<void> {
+    const query = this._queue.query(Query.type(ContextBinding));
+
+    // Process initial state before returning.
+    const initialResults = await query.run();
+    await this._updateBindings(initialResults);
+
+    // Subscribe to future changes.
+    this._ctx.onDispose(
+      query.subscribe(async () => {
+        await this._updateBindings(query.results);
+      }),
+    );
+  }
+
+  private async _updateBindings(items: ContextBinding[]): Promise<void> {
+    // Skip update if no items - preserve existing state set by bind().
+    if (items.length === 0) {
+      return;
+    }
+
+    const bindings = this._reduce(items);
+
+    // Resolve references (loading them first if needed).
+    const currentBlueprints = this._registry.get(this._blueprints);
+    const currentObjects = this._registry.get(this._objects);
+    const newBlueprints = await this._resolve(bindings.blueprints, currentBlueprints);
+    const newObjects = await this._resolve(bindings.objects, currentObjects);
+
+    // Atomic updates - subscribers notified automatically.
+    this._registry.set(this._blueprints, newBlueprints);
+    this._registry.set(this._objects, newObjects);
+
+    log('updated bindings', {
+      blueprints: newBlueprints.length,
+      objects: newObjects.length,
+    });
+  }
+
+  protected override async _close(): Promise<void> {
+    // Reset atoms to empty state.
+    this._registry.set(this._blueprints, []);
+    this._registry.set(this._objects, []);
+  }
+
+  async bind({ blueprints, objects }: BindingProps): Promise<void> {
+    const currentBlueprints = this._registry.get(this._blueprints);
+    const currentObjects = this._registry.get(this._objects);
+
+    const { added: addedBlueprints, next: nextBlueprints } = this._processBindings(blueprints, currentBlueprints);
+    const { added: addedObjects, next: nextObjects } = this._processBindings(objects, currentObjects);
+    if (!addedBlueprints.length && !addedObjects.length) {
+      return;
+    }
+
+    // Atomic updates - subscribers notified automatically.
+    this._registry.set(this._blueprints, nextBlueprints);
+    this._registry.set(this._objects, nextObjects);
+
+    log('bind', { blueprints: addedBlueprints.length, objects: addedObjects.length });
+    await this._queue.append([
+      Obj.make(ContextBinding, {
+        blueprints: {
+          added: addedBlueprints,
+          removed: [],
+        },
+        objects: {
+          added: addedObjects,
+          removed: [],
+        },
+      }),
+    ]);
+  }
+
+  async unbind({ blueprints, objects }: BindingProps): Promise<void> {
+    if (!blueprints?.length && !objects?.length) {
+      return;
+    }
+
+    log('unbind', { blueprints: blueprints?.length, objects: objects?.length });
+    await this._queue.append([
+      Obj.make(ContextBinding, {
+        blueprints: {
+          added: [],
+          removed: blueprints ?? [],
+        },
+        objects: {
+          added: [],
+          removed: objects ?? [],
+        },
+      }),
+    ]);
+  }
+
+  /**
+   * Process bindings to filter duplicates and determine next state.
+   */
+  private _processBindings<T extends Obj.Unknown>(
+    refs: Ref.Ref<T>[] | undefined,
+    current: T[],
+  ): { added: Ref.Ref<T>[]; next: T[] } {
+    const next = [...current];
+    const added: Ref.Ref<T>[] = [];
+    if (!refs?.length) {
+      return { added, next };
+    }
+
+    const seen = new Set(current.map((obj) => Obj.getDXN(obj).toString()));
+    for (const ref of refs) {
+      const dxn = ref.dxn.toString();
+      if (!seen.has(dxn)) {
+        seen.add(dxn);
+        added.push(ref);
+
+        // Only resolve target if available (has target or resolver).
+        if (ref.isAvailable) {
+          const target = ref.target;
+          if (target) {
+            next.push(target);
+          }
+        }
+      }
+    }
+
+    return { added, next };
+  }
+
+  /**
+   * Reduce results into sets of blueprints and objects.
+   */
+  private _reduce(items: ContextBinding[]): Bindings {
+    return Function.pipe(
+      items,
+      EArray.reduce(new Bindings(), (context, { blueprints, objects }) => {
+        blueprints.added.forEach((ref) => context.blueprints.add(ref));
+        blueprints.removed.forEach((ref) => context.blueprints.delete(ref));
+
+        objects.added.forEach((ref) => context.objects.add(ref));
+        objects.removed.forEach((ref) => {
+          for (const obj of context.objects) {
+            if (DXN.equalsEchoId(obj.dxn, ref.dxn)) {
+              context.objects.delete(obj);
+            }
+          }
+        });
+
+        return context;
+      }),
+    );
+  }
+
+  /**
+   * Resolve references to objects, loading them first if needed and falling back to existing objects.
+   */
+  private async _resolve<T>(refs: Iterable<Ref.Ref<T>>, current: T[]): Promise<T[]> {
+    const refArray = [...refs];
+
+    // Load all refs that need loading.
+    await Promise.all(refArray.map((ref) => ref.load()));
+
+    return refArray
+      .map((ref) => {
+        let target: T | undefined;
+        // Only resolve target if available (has target or resolver).
+        if (ref.isAvailable) {
+          target = ref.target;
+        }
+
+        // Fallback to existing object.
+        return target ?? current.find((obj) => Obj.getDXN(obj as any).toString() === ref.dxn.toString());
+      })
+      .filter(isTruthy);
+  }
+}
+
+export class AiContextService extends Context.Tag('@dxos/assistant/AiContextService')<
+  AiContextService,
+  {
+    binder: AiContextBinder;
+  }
+>() {}

package/src/conversation/conversation.test.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+import { afterEach, beforeEach, describe, expect } from 'vitest';
+
+import { Blueprint } from '@dxos/blueprints';
+import { Obj, Ref } from '@dxos/echo';
+import { EchoTestBuilder } from '@dxos/echo-db/testing';
+
+import { ContextBinding } from './context';
+import { AiConversation } from './conversation';
+
+describe('AiConversation', () => {
+  let builder: EchoTestBuilder;
+
+  beforeEach(async () => {
+    builder = await new EchoTestBuilder().open();
+  });
+
+  afterEach(async () => {
+    await builder.close();
+  });
+
+  it.effect('loads blueprints on open', () =>
+    Effect.gen(function* () {
+      const peer = yield* Effect.promise(() => builder.createPeer({ types: [Blueprint.Blueprint, ContextBinding] }));
+      const db = yield* Effect.promise(() => peer.createDatabase());
+      const queues = peer.client.constructQueueFactory(db.spaceId);
+      const queue = queues.create<ContextBinding>();
+
+      // Create blueprint.
+      const blueprint = db.add(
+        Blueprint.make({
+          key: 'example.com/blueprint/Test',
+          name: 'Test Blueprint',
+        }),
+      );
+
+      // Add blueprint to queue via binding.
+      yield* Effect.promise(() =>
+        queue.append([
+          Obj.make(ContextBinding, {
+            blueprints: {
+              added: [Ref.make(blueprint)],
+              removed: [],
+            },
+            objects: {
+              added: [],
+              removed: [],
+            },
+          }),
+        ]),
+      );
+
+      const conversation = new AiConversation({ queue });
+      yield* Effect.promise(() => conversation.open());
+
+      expect(conversation.context.getBlueprints()).toHaveLength(1);
+      expect(conversation.context.getObjects()).toHaveLength(0);
+    }),
+  );
+});