@dxos/assistant-toolkit 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/src/blueprints/linear/blueprint.ts

@@ -0,0 +1,43 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+import { SyncIssues } from './functions';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.linear';
+
+/**
+ * Agent prompt instructions for managing hierarchical task lists.
+ */
+const instructions = trim`
+  You are able to sync Linear workspaces.
+  Sometimes sync does not complete in one go and you need to call the function again.
+
+  Known workspaces:
+
+  DXOS teamId: 1127c63a-6f77-4725-9229-50f6cd47321c
+`;
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Linear',
+    description: 'Syncs Linear workspaces.',
+    instructions: {
+      source: Ref.make(Text.make(instructions)),
+    },
+    tools: Blueprint.toolDefinitions({ operations: [SyncIssues] }),
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/linear/functions/definitions.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Database } from '@dxos/echo';
+import { CredentialsService } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+
+export const SyncIssues = Operation.make({
+  meta: {
+    key: 'org.dxos.function.linear.sync-issues',
+    name: 'Linear',
+    description: 'Sync issues from Linear.',
+  },
+  input: Schema.Struct({
+    team: Schema.String.annotations({
+      description: 'Linear team id.',
+    }),
+  }),
+  output: Schema.Any,
+  services: [CredentialsService, Database.Service],
+});

package/src/blueprints/linear/functions/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * from './definitions';
+
+export const LinearHandlers = OperationHandlerSet.lazy(() => import('./sync-issues'));

package/src/blueprints/linear/functions/linear.test.ts

@@ -0,0 +1,60 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { describe, it } from '@effect/vitest';
+import * as Effect from 'effect/Effect';
+
+import { AssistantTestLayer } from '@dxos/assistant/testing';
+import { Obj, Query } from '@dxos/echo';
+import { Database } from '@dxos/echo';
+import { TestHelpers } from '@dxos/effect/testing';
+import { FunctionInvocationService } from '@dxos/functions';
+import { Person, Pipeline, Task } from '@dxos/types';
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+import { LINEAR_ID_KEY, default as fetchLinearIssues } from './sync-issues';
+
+const TestLayer = AssistantTestLayer({
+  operationHandlers: OperationHandlerSet.make(fetchLinearIssues),
+  types: [Task.Task, Person.Person, Pipeline.Pipeline],
+  credentials: [{ service: 'linear.app', apiKey: process.env.LINEAR_API_KEY }],
+  tracing: 'pretty',
+});
+
+describe.skip('Linear', { timeout: 600_000 }, () => {
+  it.effect(
+    'sync',
+    Effect.fnUntraced(
+      function* (_) {
+        yield* Database.flush();
+
+        yield* FunctionInvocationService.invokeFunction(fetchLinearIssues, {
+          team: '1127c63a-6f77-4725-9229-50f6cd47321c',
+        });
+
+        const persons = yield* Database.runQuery(Query.type(Person.Person));
+        console.log('people', {
+          count: persons.length,
+          people: persons.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
+        });
+        const projects = yield* Database.runQuery(Query.type(Pipeline.Pipeline));
+        console.log('projects', {
+          count: projects.length,
+          projects: projects.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
+        });
+        const tasks = yield* Database.runQuery(Query.type(Task.Task));
+        console.log('tasks', {
+          count: tasks.length,
+          tasks: tasks.map((_) => `(${_.id}) ${Obj.getLabel(_)} [${Obj.getKeys(_, LINEAR_ID_KEY)[0]?.id}]`),
+        });
+
+        yield* Database.flush();
+      },
+      Effect.provide(TestLayer),
+      TestHelpers.taggedTest('sync'),
+      TestHelpers.provideTestContext,
+    ),
+  );
+});

package/src/{functions/linear → blueprints/linear/functions}/sync-issues.ts

@@ -7,15 +7,17 @@ import * as HttpClient from '@effect/platform/HttpClient';
 import * as Array from 'effect/Array';
 import * as Effect from 'effect/Effect';
 import * as Function from 'effect/Function';
-import * as Schema from 'effect/Schema';
 
 import { Filter, Obj, Query, Ref, type Type } from '@dxos/echo';
-import { DatabaseService, defineFunction, withAuthorization } from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { CredentialsService, withAuthorization } from '@dxos/functions';
 import { log } from '@dxos/log';
-import { DataType } from '@dxos/schema';
+import { Operation } from '@dxos/operation';
+import { Person, Pipeline, Task } from '@dxos/types';
 
-import { syncObjects } from '../../sync';
-import { graphqlRequestBody } from '../../util';
+import { SyncIssues } from './definitions';
+import { syncObjects } from '../../../sync';
+import { graphqlRequestBody } from '../../../util';
 
 const queryIssues = `
 query Issues($teamId: String!, $after: DateTimeOrDuration!) {
@@ -35,7 +37,7 @@ query Issues($teamId: String!, $after: DateTimeOrDuration!) {
             updatedAt
             description
             assignee { id, name }
-            state { 
+            state {
                 name
             }
             project {
@@ -74,48 +76,40 @@ export const LINEAR_ID_KEY = 'linear.app/id';
 export const LINEAR_TEAM_ID_KEY = 'linear.app/teamId';
 export const LINEAR_UPDATED_AT_KEY = 'linear.app/updatedAt';
 
-export default defineFunction({
-  key: 'dxos.org/function/linear/sync-issues',
-  name: 'Linear',
-  description: 'Sync issues from Linear.',
-  inputSchema: Schema.Struct({
-    team: Schema.String.annotations({
-      description: 'Linear team id.',
-    }),
-  }),
-  handler: Effect.fnUntraced(function* ({ data }) {
-    const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization({ service: 'linear.app' })));
-
-    // Get the timestamp that was previosly synced.
-    const after = yield* getLatestUpdateTimestamp(data.team, DataType.Task);
-    log.info('will fetch', { after });
-
-    // Fetch the issues that have changed since the last sync.
-    const response = yield* client.post('https://api.linear.app/graphql', {
-      body: yield* graphqlRequestBody(queryIssues, {
-        teamId: data.team,
-        after,
-      }),
-    });
-    const json: any = yield* response.json;
-    const tasks = (json.data.team.issues.edges as any[]).map((edge: any) =>
-      mapLinearIssue(edge.node as LinearIssue, { teamId: data.team }),
-    );
-    log.info('Fetched tasks', { count: tasks.length });
-
-    // Synchronize new objects with ECHO.
-    return {
-      objects: yield* syncObjects(tasks, { foreignKeyId: LINEAR_ID_KEY }),
-      syncComplete: tasks.length < 150,
-    };
-  }, Effect.provide(FetchHttpClient.layer)),
-});
+export default SyncIssues.pipe(
+  Operation.withHandler(
+    Effect.fnUntraced(function* ({ team }) {
+      const credential = yield* CredentialsService.getCredential({ service: 'linear.app' });
+      const client = yield* HttpClient.HttpClient.pipe(Effect.map(withAuthorization(credential.apiKey!)));
+
+      const after = yield* getLatestUpdateTimestamp(team, Task.Task);
+      log.info('will fetch', { after });
+
+      const response = yield* client.post('https://api.linear.app/graphql', {
+        body: yield* graphqlRequestBody(queryIssues, {
+          teamId: team,
+          after,
+        }),
+      });
+      const json: any = yield* response.json;
+      const tasks = (json.data.team.issues.edges as any[]).map((edge: any) =>
+        mapLinearIssue(edge.node as LinearIssue, { teamId: team }),
+      );
+      log.info('Fetched tasks', { count: tasks.length });
+
+      return {
+        objects: yield* syncObjects(tasks, { foreignKeyId: LINEAR_ID_KEY }),
+        syncComplete: tasks.length < 150,
+      };
+    }, Effect.provide(FetchHttpClient.layer)),
+  ),
+);
 
 const getLatestUpdateTimestamp: (
   teamId: string,
-  dataType: Type.Obj.Any,
-) => Effect.Effect<string, never, DatabaseService> = Effect.fnUntraced(function* (teamId, dataType) {
-  const { objects: existingTasks } = yield* DatabaseService.runQuery(
+  dataType: Type.AnyObj,
+) => Effect.Effect<string, never, Database.Service> = Effect.fnUntraced(function* (teamId, dataType) {
+  const existingTasks = yield* Database.runQuery(
     Query.type(dataType).select(Filter.foreignKeys(dataType, [{ source: LINEAR_TEAM_ID_KEY, id: teamId }])),
   );
   return Function.pipe(
@@ -126,8 +120,8 @@ const getLatestUpdateTimestamp: (
   );
 });
 
-const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }): DataType.Person =>
-  Obj.make(DataType.Person, {
+const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }): Person.Person =>
+  Obj.make(Person.Person, {
     [Obj.Meta]: {
       keys: [
         {
@@ -143,8 +137,8 @@ const mapLinearPerson = (person: LinearPerson, { teamId }: { teamId: string }):
     nickname: person.name,
   });
 
-const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): DataType.Task =>
-  Obj.make(DataType.Task, {
+const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): Task.Task =>
+  Obj.make(Task.Task, {
     [Obj.Meta]: {
       keys: [
         {
@@ -170,7 +164,7 @@ const mapLinearIssue = (issue: LinearIssue, { teamId }: { teamId: string }): Dat
     project: !issue.project
       ? undefined
       : Ref.make(
-          DataType.makeProject({
+          Pipeline.make({
             [Obj.Meta]: {
               keys: [
                 {

package/src/blueprints/linear/index.ts

@@ -2,6 +2,5 @@
 // Copyright 2025 DXOS.org
 //
 
-import blueprint from './linear-blueprint';
-
-export default blueprint;
+export { default as LinearBlueprint } from './blueprint';
+export { SyncIssues, LinearHandlers } from './functions';

package/src/blueprints/markdown/blueprint.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type AppCapabilities } from '@dxos/app-toolkit';
+import { Blueprint } from '@dxos/blueprints';
+import { Ref } from '@dxos/echo';
+import { Text } from '@dxos/schema';
+import { trim } from '@dxos/util';
+
+import { Create, Read, Update } from './functions';
+
+const BLUEPRINT_KEY = 'org.dxos.blueprint.markdown';
+
+const instructions = trim`
+  You read, write & create markdown documents.
+`;
+
+const make = () =>
+  Blueprint.make({
+    key: BLUEPRINT_KEY,
+    name: 'Markdown',
+    description: 'Work with markdown documents.',
+    agentCanEnable: true,
+    instructions: {
+      source: Ref.make(Text.make(instructions)),
+    },
+    tools: Blueprint.toolDefinitions({ operations: [Create, Read, Update] }),
+  });
+
+const blueprint: AppCapabilities.BlueprintDefinition = {
+  key: BLUEPRINT_KEY,
+  make,
+};
+
+export default blueprint;

package/src/blueprints/markdown/functions/create.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Database, Ref } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { Markdown } from '@dxos/plugin-markdown/types';
+
+import { Create } from './definitions';
+
+export default Create.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ name, content }) {
+      const doc = yield* Database.add(Markdown.make({ name, content }));
+      return { document: Ref.make(doc) };
+    }),
+  ),
+);

package/src/blueprints/markdown/functions/definitions.ts

@@ -0,0 +1,80 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Database, Ref } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+import { Markdown } from '@dxos/plugin-markdown/types';
+
+export const Create = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.create',
+    name: 'Create markdown document',
+    description: 'Creates a new markdown document.',
+  },
+  input: Schema.Struct({
+    name: Schema.String.annotations({
+      description: 'Name of the document.',
+    }),
+    content: Schema.String.annotations({
+      description: 'Content of the document.',
+    }),
+  }),
+  output: Schema.Void,
+  services: [Database.Service],
+});
+
+export const Read = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.read',
+    name: 'Read markdown document',
+    description:
+      'Read markdown document. Note that result is a snapshot in time, and might have changed since the document was last read.',
+  },
+  input: Schema.Struct({
+    document: Ref.Ref(Markdown.Document).annotations({
+      description: 'The document to read.',
+    }),
+  }),
+  output: Schema.Struct({
+    content: Schema.String,
+  }),
+  services: [Database.Service],
+});
+
+export const Open = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.open',
+    name: 'Open',
+    description: 'Opens and reads the contents of a markdown document.',
+  },
+  input: Schema.Struct({
+    doc: Ref.Ref(Markdown.Document).annotations({
+      description: 'The ID of the markdown document.',
+    }),
+  }),
+  output: Schema.Struct({
+    content: Schema.String,
+  }),
+  services: [Database.Service],
+});
+
+export const Update = Operation.make({
+  meta: {
+    key: 'org.dxos.function.markdown.update',
+    name: 'Update markdown',
+    description: 'Updates the entire contents of the markdown document.',
+  },
+  input: Schema.Struct({
+    doc: Ref.Ref(Markdown.Document).annotations({
+      description: 'The ID of the document to write.',
+    }),
+    content: Schema.String.annotations({
+      description: 'New content to write to the document.',
+    }),
+  }),
+  output: Schema.Void,
+  services: [Database.Service],
+});

package/src/blueprints/markdown/functions/index.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { OperationHandlerSet } from '@dxos/operation';
+
+export * from './definitions';
+
+export const MarkdownHandlers = OperationHandlerSet.lazy(
+  () => import('./create'),
+  () => import('./read'),
+  () => import('./update'),
+);

package/src/blueprints/markdown/functions/read.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Database } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { Read } from './definitions';
+
+export default Read.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ document }) {
+      const { content } = yield* document.pipe(
+        Database.load,
+        Effect.flatMap((doc) => doc.content.pipe(Database.load)),
+      );
+      return { content };
+    }),
+  ),
+);

package/src/blueprints/markdown/functions/update.ts

@@ -0,0 +1,22 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Database, Obj } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
+
+import { Update } from './definitions';
+
+export default Update.pipe(
+  Operation.withHandler(
+    Effect.fn(function* ({ doc, content }) {
+      const document = yield* Database.load(doc);
+      const text = yield* Database.load(document.content);
+      Obj.change(text, (obj) => {
+        obj.content = content;
+      });
+    }),
+  ),
+);

package/src/blueprints/markdown/index.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { default as MarkdownBlueprint } from './blueprint';
+export {
+  Create as MarkdownCreate,
+  Read as MarkdownRead,
+  Update as MarkdownUpdate,
+  MarkdownHandlers,
+} from './functions';