@dxos/assistant 0.8.2-main.12df754 → 0.8.2-main.2f9c567

package/src/testing/query-promts.ts

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
 import { defineTool, ToolResult } from '@dxos/artifact';
 import { toJsonSchema } from '@dxos/echo-schema';
@@ -11,14 +11,14 @@ import { log } from '@dxos/log';
 import { executeQuery, formatJsonSchemaForLLM, type DataSource } from '../cypher';
 import { trim } from '../util';
 
-export const createCypherTool = (dataSource: DataSource, schemaTypes: S.Schema.Any[] = []) =>
+export const createCypherTool = (dataSource: DataSource, schemaTypes: Schema.Schema.Any[] = []) =>
   defineTool('dxos.org/echo', {
     name: 'query',
     description:
       'Query the ECHO graph database in cypher query language. Returns data from the database.' +
       (schemaTypes.length > 0 ? `\n\n${createSystemPrompt(schemaTypes)}` : ''),
-    schema: S.Struct({
-      query: S.String.annotations({
+    schema: Schema.Struct({
+      query: Schema.String.annotations({
         description: `
           A valid cypher query string to execute.
           Query must have one MATCH clause.
@@ -55,7 +55,7 @@ export const createCypherTool = (dataSource: DataSource, schemaTypes: S.Schema.A
     },
   });
 
-export const createSystemPrompt = (schemaTypes: S.Schema.Any[]) => trim`
+export const createSystemPrompt = (schemaTypes: Schema.Schema.Any[]) => trim`
   You have access to ECHO graph database. You can query the database to get data to satisfy user prompts.
 
   Database schema is defined in pseud-cypher syntax. The schema is:

package/src/testing/query.test.ts

@@ -14,7 +14,7 @@ import { AI_SERVICE_ENDPOINT } from './defs';
 import { createLogger } from './logger';
 import { createCypherTool, createSystemPrompt } from './query-promts';
 import { createTestData, seedTestData } from './test-data';
-import { Contact, Org, Project, Task } from './test-schema';
+import { Contact, Organization, Project, Task } from './test-schema';
 import { AIServiceEdgeClient, DEFAULT_EDGE_MODEL } from '../ai-service';
 import { runLLM } from '../conversation';
 import { EchoDataSource } from '../cypher';
@@ -25,7 +25,7 @@ const client = new AIServiceEdgeClient({
 
 test.skip('cypher query', async () => {
   const dataSource = createTestData();
-  const schemaTypes = [Org, Project, Task, Contact];
+  const schemaTypes = [Organization, Project, Task, Contact];
 
   const cypherTool = createCypherTool(dataSource);
 
@@ -56,7 +56,7 @@ test.skip('query ECHO', async () => {
   await using builder = await new EchoTestBuilder().open();
   const { db, graph } = await builder.createDatabase();
 
-  const schemaTypes = [Org, Project, Task, Contact];
+  const schemaTypes = [Organization, Project, Task, Contact];
   graph.schemaRegistry.addSchema(schemaTypes);
 
   seedTestData(db);

package/src/testing/test-data.ts

@@ -2,13 +2,20 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Schema as S } from 'effect';
+import { type Schema } from 'effect';
 
 import { raise } from '@dxos/debug';
 import type { EchoDatabase } from '@dxos/echo-db';
-import { JSON_SCHEMA_ECHO_REF_ID, ObjectId, toJsonSchema, type JsonSchemaType, type Ref } from '@dxos/echo-schema';
+import {
+  JSON_SCHEMA_ECHO_REF_ID,
+  ObjectId,
+  toJsonSchema,
+  type JsonSchemaType,
+  type Ref,
+  Ref as RefImpl,
+} from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
-import { live, makeRef } from '@dxos/live-object';
+import { live } from '@dxos/live-object';
 
 import {
   type DataSource,
@@ -17,7 +24,7 @@ import {
   formatInferredRelationshipLabel,
   formatNodeLabel,
 } from '../cypher';
-import { Contact, Org, Project, Task } from '../testing';
+import { Contact, Organization, Project, Task } from '../testing';
 
 export const seedTestData = (db: EchoDatabase) => {
   const contactRich = db.add(
@@ -60,79 +67,79 @@ export const seedTestData = (db: EchoDatabase) => {
   const _taskComposer1 = db.add(
     live(Task, {
       name: 'Optimize startup performance',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactJosiah),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactJosiah),
     }),
   );
   const _taskComposer2 = db.add(
     live(Task, {
       name: 'Create form builder',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactRich),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactRich),
     }),
   );
   const _taskComposer3 = db.add(
     live(Task, {
       name: 'Add support for custom themes',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactJosiah),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactJosiah),
     }),
   );
   const _taskComposer5 = db.add(
     live(Task, {
       name: 'Implement community plugin',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactFred),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactFred),
     }),
   );
   const _taskComposer4 = db.add(
     live(Task, {
       name: 'Implement dark mode',
-      project: makeRef(projectComposer),
-      assignee: makeRef(contactRich),
+      project: RefImpl.make(projectComposer),
+      assignee: RefImpl.make(contactRich),
     }),
   );
   const _taskEcho1 = db.add(
     live(Task, {
       name: 'Implement cypher query engine',
-      project: makeRef(projectEcho),
-      assignee: makeRef(contactDima),
+      project: RefImpl.make(projectEcho),
+      assignee: RefImpl.make(contactDima),
     }),
   );
   const _taskEcho2 = db.add(
     live(Task, {
       name: 'Add schema editor',
-      project: makeRef(projectEcho),
-      assignee: makeRef(contactRich),
+      project: RefImpl.make(projectEcho),
+      assignee: RefImpl.make(contactRich),
     }),
   );
   const _taskDoodles1 = db.add(
     live(Task, {
       name: 'Add support for custom themes',
-      project: makeRef(projectDoodles),
-      assignee: makeRef(contactFred),
+      project: RefImpl.make(projectDoodles),
+      assignee: RefImpl.make(contactFred),
     }),
   );
   const _taskDoodles2 = db.add(
     live(Task, {
       name: 'Implement dark mode',
-      project: makeRef(projectDoodles),
-      assignee: makeRef(contactJosiah),
+      project: RefImpl.make(projectDoodles),
+      assignee: RefImpl.make(contactJosiah),
     }),
   );
 
   const _orgDxos = db.add(
-    live(Org, {
+    live(Organization, {
       name: 'DXOS',
-      employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
-      projects: [makeRef(projectEcho)],
+      employees: [RefImpl.make(contactRich), RefImpl.make(contactJosiah), RefImpl.make(contactDima)],
+      projects: [RefImpl.make(projectEcho)],
     }),
   );
   const _orgBraneframe = db.add(
-    live(Org, {
+    live(Organization, {
       name: 'Braneframe',
-      employees: [makeRef(contactJosiah), makeRef(contactRich)],
-      projects: [makeRef(projectComposer)],
+      employees: [RefImpl.make(contactJosiah), RefImpl.make(contactRich)],
+      projects: [RefImpl.make(projectComposer)],
     }),
   );
 };
@@ -174,69 +181,69 @@ export const createTestData = (): MockDataSource => {
   const _taskComposer1 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Optimize startup performance',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactJosiah),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactJosiah),
   });
   const _taskComposer2 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Create form builder',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactRich),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactRich),
   });
   const _taskComposer3 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Add support for custom themes',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactJosiah),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactJosiah),
   });
   const _taskComposer5 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement community plugin',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactFred),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactFred),
   });
   const _taskComposer4 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement dark mode',
-    project: makeRef(projectComposer),
-    assignee: makeRef(contactRich),
+    project: RefImpl.make(projectComposer),
+    assignee: RefImpl.make(contactRich),
   });
   const _taskEcho1 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement cypher query engine',
-    project: makeRef(projectEcho),
-    assignee: makeRef(contactDima),
+    project: RefImpl.make(projectEcho),
+    assignee: RefImpl.make(contactDima),
   });
   const _taskEcho2 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Add schema editor',
-    project: makeRef(projectEcho),
-    assignee: makeRef(contactRich),
+    project: RefImpl.make(projectEcho),
+    assignee: RefImpl.make(contactRich),
   });
   const _taskDoodles1 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Add support for custom themes',
-    project: makeRef(projectDoodles),
-    assignee: makeRef(contactFred),
+    project: RefImpl.make(projectDoodles),
+    assignee: RefImpl.make(contactFred),
   });
   const _taskDoodles2 = dataSource.add(Task, {
     id: ObjectId.random(),
     name: 'Implement dark mode',
-    project: makeRef(projectDoodles),
-    assignee: makeRef(contactJosiah),
+    project: RefImpl.make(projectDoodles),
+    assignee: RefImpl.make(contactJosiah),
   });
 
-  const _orgDxos = dataSource.add(Org, {
+  const _orgDxos = dataSource.add(Organization, {
     id: ObjectId.random(),
     name: 'DXOS',
-    employees: [makeRef(contactRich), makeRef(contactJosiah), makeRef(contactDima)],
-    projects: [makeRef(projectEcho)],
+    employees: [RefImpl.make(contactRich), RefImpl.make(contactJosiah), RefImpl.make(contactDima)],
+    projects: [RefImpl.make(projectEcho)],
   });
-  const _orgBraneframe = dataSource.add(Org, {
+  const _orgBraneframe = dataSource.add(Organization, {
     id: ObjectId.random(),
     name: 'Braneframe',
-    employees: [makeRef(contactJosiah), makeRef(contactRich)],
-    projects: [makeRef(projectComposer)],
+    employees: [RefImpl.make(contactJosiah), RefImpl.make(contactRich)],
+    projects: [RefImpl.make(projectComposer)],
   });
   dataSource.computeGraph();
 
@@ -247,7 +254,7 @@ export class MockDataSource implements DataSource {
   objects: Record<
     string,
     {
-      schema: S.Schema.All;
+      schema: Schema.Schema.All;
       typeDxn: string;
       id: string;
       data: unknown;
@@ -258,7 +265,7 @@ export class MockDataSource implements DataSource {
     string,
     {
       json: JsonSchemaType;
-      instance: S.Schema.All;
+      instance: Schema.Schema.All;
     }
   > = {};
 
@@ -273,7 +280,7 @@ export class MockDataSource implements DataSource {
     return this.relationships.filter((relationship) => !label || relationship.label === label);
   }
 
-  add<S extends S.Schema.All>(schema: S, data: S.Schema.Type<S>) {
+  add<S extends Schema.Schema.All>(schema: S, data: Schema.Schema.Type<S>) {
     invariant(typeof data.id === 'string', 'Data must have an id');
     const jsonSchema = toJsonSchema(schema);
     if (!this.schema[jsonSchema.$id!]) {

package/src/testing/test-schema.ts

@@ -2,22 +2,19 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema as S } from 'effect';
+import { Schema } from 'effect';
 
-import { EntityKind, TypeAnnotationId, Ref } from '@dxos/echo-schema';
+import { EntityKind, TypeAnnotationId, Ref, ObjectId } from '@dxos/echo-schema';
 
-// TODO(burdon): Reconcile with sdk/schema/testing.
-// TODO(burdon): Convert interface to type.
+// TODO(burdon): Remove (use @dxos/schema DataType).
 
-// TODO(dmaretskyi): Extract.
-export const ObjectId = S.String.annotations({ description: 'The unique object identifier.' });
-
-export const Contact = S.Struct({
+/** @deprecated */
+export const Contact = Schema.Struct({
   id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the person.' }),
-  email: S.optional(S.String).annotations({ description: 'Email address.' }),
+  name: Schema.String.annotations({ description: 'The name of the person.' }),
+  email: Schema.optional(Schema.String).annotations({ description: 'Email address.' }),
 })
-  .pipe(S.mutable)
+  .pipe(Schema.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -26,14 +23,15 @@ export const Contact = S.Struct({
     },
     description: 'Contact information.',
   });
-export interface Contact extends S.Schema.Type<typeof Contact> {}
+export interface Contact extends Schema.Schema.Type<typeof Contact> {}
 
-export const Project = S.Struct({
+/** @deprecated */
+export const Project = Schema.Struct({
   id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the project.' }),
-  description: S.optional(S.String).annotations({ description: 'The description of the project.' }),
+  name: Schema.String.annotations({ description: 'The name of the project.' }),
+  description: Schema.optional(Schema.String).annotations({ description: 'The description of the project.' }),
 })
-  .pipe(S.mutable)
+  .pipe(Schema.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -42,16 +40,16 @@ export const Project = S.Struct({
     },
     description: 'Contact information.',
   });
-export interface Project extends S.Schema.Type<typeof Project> {}
+export interface Project extends Schema.Schema.Type<typeof Project> {}
 
-export const Task = S.Struct({
+export const Task = Schema.Struct({
   id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the task.' }),
-  description: S.optional(S.String).annotations({ description: 'The description of the task.' }),
+  name: Schema.String.annotations({ description: 'The name of the task.' }),
+  description: Schema.optional(Schema.String).annotations({ description: 'The description of the task.' }),
   project: Ref(Project),
   assignee: Ref(Contact),
 })
-  .pipe(S.mutable)
+  .pipe(Schema.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
@@ -60,21 +58,22 @@ export const Task = S.Struct({
     },
     description: 'Contact information.',
   });
-export interface Task extends S.Schema.Type<typeof Task> {}
+export interface Task extends Schema.Schema.Type<typeof Task> {}
 
-export const Org = S.Struct({
+/** @deprecated */
+export const Organization = Schema.Struct({
   id: ObjectId,
-  name: S.String.annotations({ description: 'The name of the organization.' }),
-  projects: S.Array(Ref(Project)),
-  employees: S.Array(Ref(Contact)),
+  name: Schema.String.annotations({ description: 'The name of the organization.' }),
+  projects: Schema.Array(Ref(Project)),
+  employees: Schema.Array(Ref(Contact)),
 })
-  .pipe(S.mutable)
+  .pipe(Schema.mutable)
   .annotations({
     [TypeAnnotationId]: {
       kind: EntityKind.Object,
-      typename: 'example.com/type/Org',
+      typename: 'example.com/type/Organization',
       version: '0.1.0',
     },
     description: 'Contact information.',
   });
-export interface Org extends S.Schema.Type<typeof Org> {}
+export interface Organization extends Schema.Schema.Type<typeof Organization> {}