@dxos/plugin-assistant 0.8.4-main.937b3ca → 0.8.4-main.9be5663bfe

package/src/containers/AgentArticle/AgentArticle.stories.tsx

@@ -0,0 +1,105 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Plan, Agent } from '@dxos/assistant-toolkit';
+import { Obj, Ref } from '@dxos/echo';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { PreviewPlugin } from '@dxos/plugin-preview';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { random } from '@dxos/random';
+import { Filter, useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Loading } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+import { createObjectFactory } from '@dxos/schema/testing';
+import { Message, Organization, Person } from '@dxos/types';
+
+import { createMessage } from '#testing';
+
+import { translations } from '../../translations';
+import { AgentArticle } from './AgentArticle';
+
+random.seed(1);
+
+type DefaultStoryProps = {};
+
+const DefaultStory = (_: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const [agent] = useQuery(space?.db, Filter.type(Agent.Agent));
+  if (!agent) {
+    return <Loading />;
+  }
+
+  return <AgentArticle role='article' subject={agent} attendableId='story' />;
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/AgentArticle',
+  render: DefaultStory,
+  decorators: [
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Agent.Agent, Message.Message, Plan.Plan, Text.Text, Organization.Organization, Person.Person],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              const factory = createObjectFactory(space.db, random as any);
+              const created = yield* Effect.promise(() =>
+                factory([
+                  { type: Organization.Organization, count: 10 },
+                  { type: Person.Person, count: 10 },
+                ]),
+              );
+
+              const inputQueue = space.queues.create();
+              yield* Effect.promise(() =>
+                inputQueue.append([
+                  createMessage('user', [{ _tag: 'text', text: 'Summarize the current artifacts.' }]),
+                  createMessage('assistant', [
+                    { _tag: 'text', text: 'Here is a quick overview of the organizations and contacts in context.' },
+                  ]),
+                  createMessage('user', [{ _tag: 'text', text: 'Flag anything that needs follow-up.' }]),
+                ]),
+              );
+
+              space.db.add(
+                Obj.make(Agent.Agent, {
+                  spec: Ref.make(Text.make()),
+                  plan: Ref.make(Plan.makePlan({ tasks: [] })),
+                  artifacts: created.map((obj) => ({
+                    name: Obj.getLabel(obj) ?? 'Artifact',
+                    data: Ref.make(obj),
+                  })),
+                  queue: Ref.fromDXN(inputQueue.dxn),
+                  subscriptions: [],
+                }),
+              );
+            }),
+        }),
+        StorybookPlugin({}),
+        PreviewPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<DefaultStoryProps>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/AgentArticle/AgentArticle.tsx

@@ -0,0 +1,157 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import * as Function from 'effect/Function';
+import * as Option from 'effect/Option';
+import React, { forwardRef, useMemo, useState } from 'react';
+
+import { Surface } from '@dxos/app-framework/ui';
+import { useObjectMenuItems, type AppSurface } from '@dxos/app-toolkit/ui';
+import { type Agent } from '@dxos/assistant-toolkit';
+import { Annotation, Filter, Obj, Query } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { useQuery } from '@dxos/react-client/echo';
+import { Card, Input, Message, Panel, ScrollArea, Toolbar, useTranslation } from '@dxos/react-ui';
+import { Masonry } from '@dxos/react-ui-masonry';
+import { Menu } from '@dxos/react-ui-menu';
+import { Focus, Mosaic, type MosaicTileProps } from '@dxos/react-ui-mosaic';
+import { composable } from '@dxos/ui-theme';
+import { isNonNullable } from '@dxos/util';
+
+import { meta } from '#meta';
+
+export type AgentArticleProps = AppSurface.ObjectArticleProps<Agent.Agent>;
+
+export const AgentArticle = ({ role, subject: agent }: AgentArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  const [viewport, setViewport] = useState<HTMLElement | null>(null);
+
+  const inputQueue = useAtomValue(
+    AtomObj.make(agent).pipe((_) =>
+      Atom.make((get) =>
+        Option.fromNullable(get(_).queue).pipe(Option.map(AtomRef.make), Option.map(get), Option.getOrUndefined),
+      ),
+    ),
+  );
+
+  const inputQueueObjects = useQuery(inputQueue, Query.select(Filter.everything()));
+
+  const artifacts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(agent).pipe((agent) =>
+          Atom.make((get) => {
+            return get(agent)
+              .artifacts.map((artifact) => get(AtomRef.make(artifact.data)))
+              .filter(isNonNullable);
+          }),
+        ),
+      [agent],
+    ),
+  );
+
+  return (
+    <Panel.Root role={role}>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root />
+      </Panel.Toolbar>
+      <Panel.Content className='dx-container flex flex-col'>
+        {artifacts.length === 0 && (
+          <Message.Root classNames='m-2' valence='info'>
+            <Message.Title>{t('project-empty-spec.message')}</Message.Title>
+            <Message.Content>{t('project-empty-spec.description')}</Message.Content>
+          </Message.Root>
+        )}
+
+        {/* TODO(burdon): Add popovers for documentation. */}
+        <div role='none' className='dx-container grid grid-cols-2 gap-2 px-2'>
+          <div role='none' className='dx-container flex flex-col'>
+            <Input.Root>
+              <Input.Label>{t('artifacts.label')}</Input.Label>
+            </Input.Root>
+            <Masonry.Root Tile={MasonryArtifactTile}>
+              <Masonry.Content items={artifacts} getId={(item: Obj.Unknown) => item.id} />
+            </Masonry.Root>
+          </div>
+          <div role='none' className='dx-container flex flex-col'>
+            <Input.Root>
+              <Input.Label>{t('input-queue.label')}</Input.Label>
+            </Input.Root>
+            <Mosaic.Container asChild withFocus autoScroll={viewport}>
+              <ScrollArea.Root orientation='vertical' padding thin>
+                <ScrollArea.Viewport ref={setViewport}>
+                  <Mosaic.VirtualStack
+                    Tile={StackTile}
+                    classNames='gap-2'
+                    draggable={false}
+                    estimateSize={() => 160}
+                    gap={8}
+                    getId={(item: Obj.Unknown) => item.id}
+                    getScrollElement={() => viewport}
+                    items={inputQueueObjects}
+                  />
+                </ScrollArea.Viewport>
+              </ScrollArea.Root>
+            </Mosaic.Container>
+          </div>
+        </div>
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+const ArtifactTileCard = composable<HTMLDivElement, { data: Obj.Unknown }>(({ data, ...props }, forwardedRef) => {
+  const objectMenuItems = useObjectMenuItems(data);
+  const icon = Function.pipe(
+    Obj.getSchema(data),
+    Option.fromNullable,
+    Option.flatMap(Annotation.IconAnnotation.get),
+    Option.map(({ icon }) => icon),
+    Option.getOrElse(() => 'ph--placeholder--regular'),
+  );
+
+  return (
+    <Card.Root {...props} ref={forwardedRef} data-testid='board-item' fullWidth>
+      <Card.Toolbar>
+        <Card.IconBlock padding>
+          <Card.Icon icon={icon} />
+        </Card.IconBlock>
+        <Card.Title>{Obj.getLabel(data)}</Card.Title>
+        {/* TODO(wittjosiah): Reconcile with Card.Menu. */}
+        <Card.IconBlock padding>
+          <Menu.Trigger asChild disabled={!objectMenuItems?.length}>
+            <Toolbar.IconButton iconOnly variant='ghost' icon='ph--dots-three-vertical--regular' label='Actions' />
+          </Menu.Trigger>
+          <Menu.Content items={objectMenuItems} />
+        </Card.IconBlock>
+      </Card.Toolbar>
+      <Card.Content>
+        <Surface.Surface role='card--content' limit={1} data={{ subject: data } satisfies AppSurface.ObjectCardData} />
+      </Card.Content>
+    </Card.Root>
+  );
+});
+
+ArtifactTileCard.displayName = 'ArtifactTileCard';
+
+const MasonryArtifactTile = ({ data }: { data: Obj.Unknown; index: number }) => (
+  <Menu.Root>
+    <ArtifactTileCard data={data} />
+  </Menu.Root>
+);
+
+const StackTile = forwardRef<HTMLDivElement, MosaicTileProps<Obj.Unknown>>(
+  ({ data, location, debug, current }, forwardedRef) => (
+    <Menu.Root>
+      <Mosaic.Tile asChild id={data.id} data={data} location={location} debug={debug}>
+        <Focus.Item asChild current={current}>
+          <ArtifactTileCard ref={forwardedRef} data={data} />
+        </Focus.Item>
+      </Mosaic.Tile>
+    </Menu.Root>
+  ),
+);
+
+StackTile.displayName = 'StackTile';

package/src/containers/AgentArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { AgentArticle as default } from './AgentArticle';

package/src/containers/AgentProperties/AgentProperties.stories.tsx

@@ -0,0 +1,91 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Plan, Agent } from '@dxos/assistant-toolkit';
+import { Obj, Ref } from '@dxos/echo';
+import { AutomationPlugin } from '@dxos/plugin-automation';
+import { ClientPlugin } from '@dxos/plugin-client';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { Filter, useQuery, useSpaces } from '@dxos/react-client/echo';
+import { ObjectProperties } from '@dxos/react-ui-form';
+import { Loading, withLayout } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+import { Organization } from '@dxos/types';
+
+import { AssistantPlugin } from '../../AssistantPlugin';
+import { translations } from '../../translations';
+import { AgentProperties } from './AgentProperties';
+
+type DefaultStoryProps = {};
+
+const DefaultStory = (_: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const [agent] = useQuery(space?.db, Filter.type(Agent.Agent));
+  if (!agent) {
+    return <Loading />;
+  }
+
+  return (
+    <ObjectProperties object={agent}>
+      <AgentProperties role='object-properties' subject={agent} />
+    </ObjectProperties>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-assistant/containers/AgentProperties',
+  render: DefaultStory,
+  decorators: [
+    withLayout({ layout: 'column' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          types: [Agent.Agent, Plan.Plan, Text.Text, Organization.Organization],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              const organization = space.db.add(
+                Obj.make(Organization.Organization, {
+                  name: 'Acme Corp',
+                  description: 'Sample organization for the story.',
+                }),
+              );
+
+              space.db.add(
+                Obj.make(Agent.Agent, {
+                  spec: Ref.make(Text.make('Initiative spec for the story.')),
+                  plan: Ref.make(Plan.makePlan({ tasks: [] })),
+                  artifacts: [{ name: 'Organization', data: Ref.make(organization) }],
+                  subscriptions: [],
+                }),
+              );
+            }),
+        }),
+        StorybookPlugin({}),
+        AutomationPlugin(),
+        AssistantPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<DefaultStoryProps>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/AgentProperties/AgentProperties.tsx

@@ -0,0 +1,169 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Atom } from '@effect-atom/atom';
+import { useAtomValue } from '@effect-atom/atom-react';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import React, { useCallback, useEffect, useMemo } from 'react';
+
+import { useCapability } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { Agent, SyncTriggers } from '@dxos/assistant-toolkit';
+import { DXN, Obj, Ref } from '@dxos/echo';
+import { AtomObj, AtomRef } from '@dxos/echo-atom';
+import { createDocAccessor } from '@dxos/echo-db';
+import { QueueService } from '@dxos/functions';
+import { log } from '@dxos/log';
+import { Operation } from '@dxos/operation';
+import { AutomationCapabilities } from '@dxos/plugin-automation/types';
+import { Filter, useQuery } from '@dxos/react-client/echo';
+import { Button, Input, useTranslation } from '@dxos/react-ui';
+import { Editor } from '@dxos/react-ui-editor';
+import { FeedAnnotation } from '@dxos/schema';
+import {
+  createBasicExtensions,
+  createDataExtensions,
+  createMarkdownExtensions,
+  createThemeExtensions,
+  decorateMarkdown,
+  documentSlots,
+} from '@dxos/ui-editor';
+
+import { meta } from '#meta';
+
+export type AgentPropertiesProps = AppSurface.ObjectPropertiesProps<Agent.Agent>;
+
+export const AgentProperties = ({ subject: agent }: AgentPropertiesProps) => {
+  const { t } = useTranslation(meta.id);
+
+  // TODO(burdon): Factor out.
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+  const handleResetHistory = useCallback(async () => {
+    const runtime = computeRuntime.getRuntime(Obj.getDatabase(agent)!.spaceId);
+    await runtime.runPromise(Agent.resetChatHistory(agent));
+    if (!agent.queue) {
+      await runtime.runPromise(
+        Effect.gen(function* () {
+          const queue = yield* QueueService.createQueue();
+          Obj.change(agent, (agent) => {
+            agent.queue = Ref.fromDXN(queue.dxn);
+          });
+        }),
+      );
+    }
+  }, [agent, computeRuntime]);
+
+  const spec = useAtomValue(AtomRef.make(agent.spec));
+
+  useEffect(() => {
+    const db = Obj.getDatabase(agent);
+    if (!db) return;
+    return Obj.subscribe(agent, () => {
+      queueMicrotask(() => {
+        const runtime = computeRuntime.getRuntime(db.spaceId);
+        runtime.runPromise(Operation.invoke(SyncTriggers, { agent: Ref.make(agent) })).catch((err) => log.catch(err));
+      });
+    });
+  }, [agent, computeRuntime]);
+
+  const db = Obj.getDatabase(agent);
+  const feedFilter = useMemo(() => {
+    if (!db) {
+      return Filter.nothing();
+    }
+
+    const schemas = db.schemaRegistry.query({ location: ['database', 'runtime'] }).runSync();
+    const feedSchemas = schemas.filter((schema) => {
+      const annotation = FeedAnnotation.get(schema);
+      return Option.isSome(annotation) && annotation.value === true;
+    });
+
+    if (feedSchemas.length === 0) {
+      return Filter.nothing();
+    }
+
+    return Filter.or(...feedSchemas.map((schema) => Filter.type(schema)));
+  }, [db]);
+  const subscribableObjects = useQuery(db, feedFilter);
+
+  const existingSubscripts = useAtomValue(
+    useMemo(
+      () =>
+        AtomObj.make(agent).pipe((_) =>
+          Atom.make((get) => {
+            const agentObj = get(_);
+            const selectedSubscriptions: Obj.Unknown[] = subscribableObjects.filter((object) =>
+              agentObj.subscriptions.some((subscription) => DXN.equals(subscription.dxn, Obj.getDXN(object))),
+            );
+
+            return selectedSubscriptions;
+          }),
+        ),
+      [agent, subscribableObjects],
+    ),
+  );
+
+  const extension = useMemo(
+    () =>
+      spec && [
+        createBasicExtensions({ placeholder: t('agent.spec.placeholder') }),
+        createThemeExtensions({
+          syntaxHighlighting: true,
+          slots: {
+            ...documentSlots,
+            scroller: {
+              className: 'min-h-[2lh]',
+            },
+          },
+        }),
+        createDataExtensions({ id: agent.id, text: createDocAccessor(spec, ['content']) }),
+        createMarkdownExtensions(),
+        decorateMarkdown(),
+      ],
+    [spec, agent.id, t],
+  );
+
+  return (
+    <div role='none' className='dx-expander flex flex-col'>
+      <Input.Root>
+        <Input.Label>{t('subscriptions.label')}</Input.Label>
+      </Input.Root>
+
+      {subscribableObjects.map((object) => (
+        <Input.Root key={object.id}>
+          <div className='flex items-center gap-2'>
+            <Input.Checkbox
+              checked={existingSubscripts.includes(object)}
+              onCheckedChange={(checked) => {
+                Obj.change(agent, (agent) => {
+                  if (checked) {
+                    agent.subscriptions.push(Ref.fromDXN(Obj.getDXN(object)));
+                  } else {
+                    agent.subscriptions = agent.subscriptions.filter(
+                      (subscription) => !DXN.equals(subscription.dxn, Obj.getDXN(object)),
+                    );
+                  }
+                });
+              }}
+            />
+            <Input.Label>{Obj.getLabel(object) ?? object.id}</Input.Label>
+          </div>
+        </Input.Root>
+      ))}
+
+      <Input.Root>
+        <Input.Label>{t('instructions.label')}</Input.Label>
+        {spec && (
+          <Editor.Root>
+            <Editor.Content classNames='pb-form-gap' extensions={extension} />
+          </Editor.Root>
+        )}
+      </Input.Root>
+
+      {/* TODO(burdon): Move into toolbar in parent. */}
+      <Button onClick={handleResetHistory}>{t('reset-history.button')}</Button>
+    </div>
+  );
+};

package/src/containers/AgentProperties/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+export { AgentProperties as default } from './AgentProperties';

package/src/containers/BlueprintArticle/BlueprintArticle.tsx

@@ -0,0 +1,29 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { type Blueprint } from '@dxos/blueprints';
+import { Panel, Toolbar } from '@dxos/react-ui';
+import { useAttention } from '@dxos/react-ui-attention';
+
+import { TemplateEditor } from '#components';
+
+export type BlueprintArticleProps = AppSurface.ObjectArticleProps<Blueprint.Blueprint>;
+
+export const BlueprintArticle = ({ role, attendableId, subject }: BlueprintArticleProps) => {
+  const { hasAttention } = useAttention(attendableId);
+
+  return (
+    <Panel.Root role={role} classNames='dx-document'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} />
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TemplateEditor id={subject.id} template={subject.instructions} />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/BlueprintArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { BlueprintArticle as default } from './BlueprintArticle';